diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt index 41651e2fc7c..bbb6464efd5 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt @@ -242,7 +242,10 @@ class K2JVMCompiler : CLICompiler() { arguments: K2JVMCompilerArguments): Boolean { if (arguments.useJavac) { environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) - return environment.registerJavac(compileJava = arguments.compileJava, arguments = arguments.javacArguments) + if (arguments.compileJava) { + environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true) + } + return environment.registerJavac(arguments = arguments.javacArguments) } return true diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt index 8e23379b2ac..295ae1cc3e7 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt @@ -275,10 +275,11 @@ class KotlinCoreEnvironment private constructor( fun registerJavac( javaFiles: List = allJavaFiles, kotlinFiles: List = sourceFiles, - compileJava: Boolean = false, - arguments: Array? = null + arguments: Array? = null, + bootClasspath: List? = null, + sourcePath: List? = null ): Boolean { - return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, compileJava, arguments) + return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath, CliLightClassGenerationSupport(project)) } private val applicationEnvironment: CoreApplicationEnvironment diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt index dcfc72b025d..f6df398420a 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt @@ -159,7 +159,7 @@ object KotlinToJVMBytecodeCompiler { writeOutput(state.configuration, state.factory, null) } - if (projectConfiguration.getBoolean(JVMConfigurationKeys.USE_JAVAC)) { + if (projectConfiguration.getBoolean(JVMConfigurationKeys.COMPILE_JAVA)) { val singleModule = chunk.singleOrNull() if (singleModule != null) { return JavacWrapper.getInstance(environment.project).use { diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/JavacWrapperRegistrar.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/JavacWrapperRegistrar.kt index b720bac3395..2bfe2e547ef 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/JavacWrapperRegistrar.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/JavacWrapperRegistrar.kt @@ -20,6 +20,7 @@ import com.intellij.mock.MockProject import com.sun.tools.javac.util.Context import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING +import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys @@ -36,8 +37,10 @@ object JavacWrapperRegistrar { configuration: CompilerConfiguration, javaFiles: List, kotlinFiles: List, - compileJava: Boolean, - arguments: Array? + arguments: Array?, + bootClasspath: List?, + sourcePath: List?, + lightClassGenerationSupport: CliLightClassGenerationSupport ): Boolean { val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) @@ -54,8 +57,11 @@ object JavacWrapperRegistrar { val jvmClasspathRoots = configuration.jvmClasspathRoots val outputDirectory = configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY) + val compileJava = configuration.getBoolean(JVMConfigurationKeys.COMPILE_JAVA) + val kotlinSupertypesResolver = KotlinSupertypeResolverImpl(lightClassGenerationSupport) - val javacWrapper = JavacWrapper(javaFiles, kotlinFiles, arguments, jvmClasspathRoots, compileJava, outputDirectory, context) + val javacWrapper = JavacWrapper(javaFiles, kotlinFiles, arguments, jvmClasspathRoots, bootClasspath, sourcePath, + kotlinSupertypesResolver, compileJava, outputDirectory, context) project.registerService(JavacWrapper::class.java, javacWrapper) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/KotlinSupertypeResolverImpl.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/KotlinSupertypeResolverImpl.kt new file mode 100644 index 00000000000..8c0405e8383 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/KotlinSupertypeResolverImpl.kt @@ -0,0 +1,39 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.cli.jvm.javac + +import com.intellij.psi.PsiClass +import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport +import org.jetbrains.kotlin.javac.KotlinSupertypeResolver +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.KtClassOrObject + +class KotlinSupertypeResolverImpl(private val lightClassGenerationSupport: CliLightClassGenerationSupport) : KotlinSupertypeResolver { + + override fun resolveSupertypes(classOrObject: KtClassOrObject): List { + val lightClass = lightClassGenerationSupport.getLightClass(classOrObject) ?: return emptyList() + + return lightClass.superTypes + .mapNotNull { it.resolve()?.computeClassId() } + } + + private fun PsiClass.computeClassId(): ClassId? = + containingClass?.computeClassId()?.createNestedClassId(Name.identifier(name!!)) ?: qualifiedName?.let { ClassId.topLevel(FqName(it)) } + +} \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java index 2083df84718..111ef560f75 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java @@ -115,7 +115,10 @@ public class JVMConfigurationKeys { CompilerConfigurationKey.create("use fast class files reading implementation [experimental]"); public static final CompilerConfigurationKey USE_JAVAC = - CompilerConfigurationKey.create("use javac"); + CompilerConfigurationKey.create("use javac [experimental]"); + + public static final CompilerConfigurationKey COMPILE_JAVA = + CompilerConfigurationKey.create("compile java files [experimental]"); public static final CompilerConfigurationKey> ADDITIONAL_JAVA_MODULES = CompilerConfigurationKey.create("additional Java modules"); diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacOptionsMapper.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacOptionsMapper.kt index bdeccd14062..d891b81c55d 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacOptionsMapper.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacOptionsMapper.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.javac +import com.sun.tools.javac.main.Option import com.sun.tools.javac.util.Options import java.util.regex.Pattern @@ -25,6 +26,8 @@ object JavacOptionsMapper { arguments.forEach { options.putOption(it) } } + fun setUTF8Encoding(options: Options) = options.put(Option.ENCODING, "UTF8") + private val optionPattern = Pattern.compile("\\s+") private fun Options.putOption(option: String) = diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt index 9693e5fbd8d..ecad83f2e8d 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt @@ -35,6 +35,7 @@ import com.sun.tools.javac.jvm.ClassReader import com.sun.tools.javac.main.JavaCompiler import com.sun.tools.javac.model.JavacElements import com.sun.tools.javac.model.JavacTypes +import com.sun.tools.javac.tree.DCTree import com.sun.tools.javac.tree.JCTree import com.sun.tools.javac.util.Context import com.sun.tools.javac.util.Log @@ -48,10 +49,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaAnnotation import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.load.java.structure.JavaClassifier import org.jetbrains.kotlin.load.java.structure.JavaPackage -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.isSubpackageOf -import org.jetbrains.kotlin.name.parentOrNull +import org.jetbrains.kotlin.name.* import org.jetbrains.kotlin.psi.KtFile import java.io.Closeable import java.io.File @@ -67,6 +65,9 @@ class JavacWrapper( kotlinFiles: Collection, arguments: Array?, jvmClasspathRoots: List, + bootClasspath: List?, + sourcePath: List?, + val kotlinSupertypeResolver: KotlinSupertypeResolver, private val compileJava: Boolean, private val outputDirectory: File?, private val context: Context @@ -88,7 +89,7 @@ class JavacWrapper( } val JAVA_LANG_ENUM by lazy { - createCommonClassifierType(CommonClassNames.JAVA_LANG_ENUM) + findClassInSymbols(CommonClassNames.JAVA_LANG_ENUM) } val JAVA_LANG_ANNOTATION_ANNOTATION by lazy { @@ -96,7 +97,10 @@ class JavacWrapper( } init { - arguments?.toList()?.let { JavacOptionsMapper.map(Options.instance(context), it) } + Options.instance(context).let { options -> + JavacOptionsMapper.setUTF8Encoding(options) + arguments?.toList()?.let { JavacOptionsMapper.map(options, it) } + } } private val javac = object : JavaCompiler(context) { @@ -106,9 +110,18 @@ class JavacWrapper( private val fileManager = context[JavaFileManager::class.java] as JavacFileManager init { + // keep javadoc comments + javac.keepComments = true // use rt.jar instead of lib/ct.sym fileManager.setSymbolFileEnabled(false) - fileManager.setLocation(StandardLocation.CLASS_PATH, jvmClasspathRoots) + bootClasspath?.let { + val cp = fileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH) + jvmClasspathRoots + fileManager.setLocation(StandardLocation.PLATFORM_CLASS_PATH, it) + fileManager.setLocation(StandardLocation.CLASS_PATH, cp) + } ?: fileManager.setLocation(StandardLocation.CLASS_PATH, jvmClasspathRoots) + sourcePath?.let { + fileManager.setLocation(StandardLocation.SOURCE_PATH, sourcePath) + } } private val names = Names.instance(context) @@ -119,25 +132,36 @@ class JavacWrapper( private val fileObjects = fileManager.getJavaFileObjectsFromFiles(javaFiles).toJavacList() private val compilationUnits: JavacList = fileObjects.map(javac::parse).toJavacList() - private val javaClasses = compilationUnits - .flatMap { unit -> - unit.typeDecls.flatMap { classDecl -> - TreeBasedClass(classDecl as JCTree.JCClassDecl, - trees.getPath(unit, classDecl), - this, - unit.sourceFile).withInnerClasses() - } - } - .associateBy(JavaClass::fqName) + private val treeBasedJavaClasses = hashMapOf() - private val javaClassesAssociatedByClassId = - javaClasses.values.associateBy { it.computeClassId() } + private val javaClassDeclarations = compilationUnits.flatMap { unit -> + unit.typeDecls.map { classDeclaration -> + val packageName = unit.packageName?.toString() ?: "" + val className = (classDeclaration as JCTree.JCClassDecl).simpleName.toString() + val classId = classId(packageName, className) + classId to Pair(classDeclaration, unit) + } + }.toMap() + + private fun getTreeBasedClass(classId: ClassId): TreeBasedClass? { + if (treeBasedJavaClasses.containsKey(classId)) { + return treeBasedJavaClasses[classId] + } + + val (classDeclaration, unit) = javaClassDeclarations[classId] ?: return null + val treeBasedClass = TreeBasedClass(classDeclaration, + trees.getPath(unit, classDeclaration), + this, + unit.sourceFile) + + return treeBasedClass.apply { treeBasedJavaClasses[classId] = this } + } private val javaPackages = compilationUnits - .mapNotNullTo(hashSetOf()) { unit -> + .mapTo(hashSetOf()) { unit -> unit.packageName?.toString()?.let { packageName -> TreeBasedPackage(packageName, this, unit.sourcefile) - } + } ?: TreeBasedPackage("", this, unit.sourcefile) } .associateBy(TreeBasedPackage::fqName) @@ -146,12 +170,11 @@ class JavacWrapper( it.sourceFile.isNameCompatible("package-info", JavaFileObject.Kind.SOURCE) && it.packageName != null }.associateBy({ FqName(it.packageName!!.toString()) }) { compilationUnit -> - compilationUnit.packageAnnotations.map { TreeBasedAnnotation(it, compilationUnit, this) } - } + compilationUnit.packageAnnotations.map { TreeBasedAnnotation(it, getTreePath(it, compilationUnit), this) } + } + val classifierResolver = ClassifierResolver(this) private val kotlinClassifiersCache = KotlinClassifiersCache(if (javaFiles.isNotEmpty()) kotlinFiles else emptyList(), this) - private val treePathResolverCache = TreePathResolverCache(this) - private val symbolBasedClassesCache = hashMapOf() private val symbolBasedPackagesCache = hashMapOf() fun compile(outDir: File? = null): Boolean = with(javac) { @@ -173,20 +196,20 @@ class JavacWrapper( javac.close() } - fun findClass(fqName: FqName, scope: GlobalSearchScope = EverythingGlobalScope()): JavaClass? { - javaClasses[fqName]?.let { javaClass -> - javaClass.virtualFile?.let { if (it in scope) return javaClass } - } - - findClassInSymbols(fqName.asString())?.let { javaClass -> - javaClass.virtualFile?.let { if (it in scope) return javaClass } - } - - return null - } - fun findClass(classId: ClassId, scope: GlobalSearchScope = EverythingGlobalScope()): JavaClass? { - javaClassesAssociatedByClassId[classId]?.let { javaClass -> + if (classId.isNestedClass) { + val pathSegments = classId.relativeClassName.pathSegments().map { it.asString() } + val outerClassId = ClassId(classId.packageFqName, Name.identifier(pathSegments.first())) + var outerClass = findClass(outerClassId, scope) ?: return null + + pathSegments.drop(1).forEach { + outerClass = outerClass.findInnerClass(Name.identifier(it)) ?: return null + } + + return outerClass + } + + getTreeBasedClass(classId)?.let { javaClass -> javaClass.virtualFile?.let { if (it in scope) return javaClass } } @@ -202,7 +225,7 @@ class JavacWrapper( return null } - fun findPackage(fqName: FqName, scope: GlobalSearchScope): JavaPackage? { + fun findPackage(fqName: FqName, scope: GlobalSearchScope = EverythingGlobalScope()): JavaPackage? { javaPackages[fqName]?.let { javaPackage -> javaPackage.virtualFile?.let { file -> if (file in scope) return javaPackage @@ -224,9 +247,9 @@ class JavacWrapper( packageSourceAnnotations[fqName] ?: emptyList() fun findClassesFromPackage(fqName: FqName): List = - javaClasses - .filterKeys { it?.parentOrNull() == fqName } - .flatMap { it.value.withInnerClasses() } + + javaClassDeclarations + .filterKeys { it.packageFqName == fqName } + .map { getTreeBasedClass(it.key)!! } + elements.getPackageElement(fqName.asString()) ?.members() ?.elements @@ -235,8 +258,9 @@ class JavacWrapper( .orEmpty() fun knownClassNamesInPackage(fqName: FqName): Set = - javaClasses.filterKeys { it?.parentOrNull() == fqName } - .mapTo(hashSetOf()) { it.value.name.asString() } + + javaClassDeclarations + .filterKeys { it.packageFqName == fqName } + .mapTo(hashSetOf()) { it.key.shortClassName.asString() } + elements.getPackageElement(fqName.asString()) ?.members_field ?.elements @@ -247,15 +271,15 @@ class JavacWrapper( fun getTreePath(tree: JCTree, compilationUnit: CompilationUnitTree): TreePath = trees.getPath(compilationUnit, tree) - fun getKotlinClassifier(fqName: FqName): JavaClass? = - kotlinClassifiersCache.getKotlinClassifier(fqName) + fun getKotlinClassifier(classId: ClassId): JavaClass? = + kotlinClassifiersCache.getKotlinClassifier(classId) fun isDeprecated(element: Element) = elements.isDeprecated(element) fun isDeprecated(typeMirror: TypeMirror) = isDeprecated(types.asElement(typeMirror)) fun resolve(treePath: TreePath): JavaClassifier? = - treePathResolverCache.resolve(treePath) + classifierResolver.resolve(treePath) fun toVirtualFile(javaFileObject: JavaFileObject): VirtualFile? = javaFileObject.toUri().let { uri -> @@ -267,18 +291,23 @@ class JavacWrapper( } } + fun hasKotlinPackage(fqName: FqName) = + if (kotlinClassifiersCache.hasPackage(fqName)) { + fqName + } + else { + null + } + + fun isDeprecatedInJavaDoc(treePath: TreePath) = + (trees.getDocCommentTree(treePath) as? DCTree.DCDocComment)?.comment?.isDeprecated ?: false + private inline fun Iterable.toJavacList() = JavacList.from(this) - private fun findClassInSymbols(fqName: String): SymbolBasedClass? { - if (symbolBasedClassesCache.containsKey(fqName)) return symbolBasedClassesCache[fqName] - - elements.getTypeElement(fqName)?.let { symbol -> - SymbolBasedClass(symbol, this, symbol.classfile) - }.let { symbolBasedClass -> - symbolBasedClassesCache[fqName] = symbolBasedClass - return symbolBasedClass - } - } + private fun findClassInSymbols(fqName: String): SymbolBasedClass? = + elements.getTypeElement(fqName)?.let { symbol -> + SymbolBasedClass(symbol, this, symbol.classfile) + } private fun findPackageInSymbols(fqName: String): SymbolBasedPackage? { if (symbolBasedPackagesCache.containsKey(fqName)) return symbolBasedPackagesCache[fqName] @@ -322,12 +351,9 @@ class JavacWrapper( } - private fun TreeBasedClass.withInnerClasses(): List = - listOf(this) + innerClasses.values.flatMap { it.withInnerClasses() } - private fun Symbol.PackageSymbol.findClass(name: String): SymbolBasedClass? { val nameParts = name.replace("$", ".").split(".") - var symbol = members_field.getElementsByName(names.fromString(nameParts.first())) + var symbol = members_field?.getElementsByName(names.fromString(nameParts.first())) ?.firstOrNull() as? Symbol.ClassSymbol ?: return null if (nameParts.size > 1) { symbol.complete() @@ -340,4 +366,4 @@ class JavacWrapper( return symbol.let { SymbolBasedClass(it, this@JavacWrapper, it.classfile) } } -} +} \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinClassifiersCache.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinClassifiersCache.kt index 45042ea12a0..f620ced3df8 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinClassifiersCache.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinClassifiersCache.kt @@ -18,51 +18,73 @@ package org.jetbrains.kotlin.javac import com.intellij.openapi.vfs.VirtualFile import com.intellij.psi.search.SearchScope +import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.load.java.JavaVisibilities import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtFile -import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject -import org.jetbrains.kotlin.javac.wrappers.trees.find -import org.jetbrains.kotlin.javac.wrappers.trees.findInner -import org.jetbrains.kotlin.javac.wrappers.trees.tryToResolveByFqName -import org.jetbrains.kotlin.javac.wrappers.trees.tryToResolveInJavaLang import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType class KotlinClassifiersCache(sourceFiles: Collection, private val javac: JavacWrapper) { - private val kotlinClasses: Map = sourceFiles.flatMap { ktFile -> - ktFile.collectDescendantsOfType().map { it.fqName to it } + - (ktFile.javaFileFacadeFqName to null) - }.toMap() + private val kotlinPackages = hashSetOf() + private val kotlinClasses: Map = + sourceFiles.flatMap { ktFile -> + kotlinPackages.add(ktFile.packageFqName) + ktFile.declarations + .filterIsInstance() + .map { it.computeClassId() to it } + }.toMap() - private val classifiers = hashMapOf() + private val classifiers = hashMapOf() - fun getKotlinClassifier(fqName: FqName) = classifiers[fqName] ?: createClassifier(fqName) + fun getKotlinClassifier(classId: ClassId) = classifiers[classId] ?: createClassifier(classId) - private fun createClassifier(fqName: FqName): JavaClass? { - if (!kotlinClasses.containsKey(fqName)) return null - val kotlinClassifier = kotlinClasses[fqName] ?: return null + fun createMockKotlinClassifier(classifier: KtClassOrObject, + classId: ClassId) = MockKotlinClassifier(classId, + classifier, + this, + javac) + .apply { classifiers[classId] = this } - return MockKotlinClassifier(fqName, - kotlinClassifier, - kotlinClassifier.typeParameters.isNotEmpty(), - javac) - .apply { classifiers[fqName] = this } + fun hasPackage(packageFqName: FqName) = kotlinPackages.contains(packageFqName) + + private fun createClassifier(classId: ClassId): JavaClass? { + if (classId.isNestedClass) { + classifiers[classId]?.let { return it } + val pathSegments = classId.relativeClassName.pathSegments().map { it.asString() } + val outerClassId = ClassId(classId.packageFqName, Name.identifier(pathSegments.first())) + var outerClass: JavaClass = kotlinClasses[outerClassId]?.let { createMockKotlinClassifier(it, outerClassId) } ?: return null + + pathSegments.drop(1).forEach { + outerClass = outerClass.findInnerClass(Name.identifier(it)) ?: return null + } + + return outerClass.apply { classifiers[classId] = this } + } + + val kotlinClassifier = kotlinClasses[classId] ?: return null + + return createMockKotlinClassifier(kotlinClassifier, classId) } } -class MockKotlinClassifier(override val fqName: FqName, +class MockKotlinClassifier(val classId: ClassId, private val classOrObject: KtClassOrObject, - val hasTypeParameters: Boolean, + private val cache: KotlinClassifiersCache, private val javac: JavacWrapper) : VirtualFileBoundJavaClass { + override val fqName: FqName + get() = classId.asSingleFqName() + override val isAbstract: Boolean get() = throw UnsupportedOperationException("Should not be called") @@ -73,32 +95,26 @@ class MockKotlinClassifier(override val fqName: FqName, get() = throw UnsupportedOperationException("Should not be called") override val visibility: Visibility - get() = throw UnsupportedOperationException("Should not be called") + get() = when (classOrObject.visibilityModifierType()) { + null, KtTokens.PUBLIC_KEYWORD -> Visibilities.PUBLIC + KtTokens.PRIVATE_KEYWORD -> Visibilities.PRIVATE + KtTokens.PROTECTED_KEYWORD -> Visibilities.PROTECTED + else -> JavaVisibilities.PACKAGE_VISIBILITY + } override val typeParameters: List get() = throw UnsupportedOperationException("Should not be called") override val supertypes: Collection - get() = classOrObject.superTypeListEntries - .map { superTypeListEntry -> - val userType = superTypeListEntry.typeAsUserType - arrayListOf().apply { - userType?.referencedName?.let { add(it) } - var qualifier = userType?.qualifier - while (qualifier != null) { - qualifier.referencedName?.let { add(it) } - qualifier = qualifier.qualifier - } - }.reversed().joinToString(separator = ".") { it } - } - .mapNotNull { resolveSupertype(it, classOrObject, javac) } + get() = javac.kotlinSupertypeResolver.resolveSupertypes(classOrObject) + .mapNotNull { javac.getKotlinClassifier(it) ?: javac.findClass(it) } .map { MockKotlinClassifierType(it) } val innerClasses: Collection get() = classOrObject.declarations.filterIsInstance() .mapNotNull { nestedClassOrObject -> - nestedClassOrObject.fqName?.let { - javac.getKotlinClassifier(it) + nestedClassOrObject.computeClassId()?.let { + cache.createMockKotlinClassifier(nestedClassOrObject, it) } } @@ -124,7 +140,13 @@ class MockKotlinClassifier(override val fqName: FqName, get() = throw UnsupportedOperationException("Should not be called") override val fields: Collection - get() = throw UnsupportedOperationException("Should not be called") + get() = classOrObject.declarations + .filterIsInstance() + .map(::MockKotlinField) + classOrObject.companionObjects.flatMap { + it.declarations + .filterIsInstance() + .map(::MockKotlinField) + } override val constructors: Collection get() = throw UnsupportedOperationException("Should not be called") @@ -149,6 +171,12 @@ class MockKotlinClassifier(override val fqName: FqName, override fun findInnerClass(name: Name) = innerClasses.find { it.name == name } + val typeParametersNumber: Int + get() = classOrObject.typeParameters.size + + val hasTypeParameters: Boolean + get() = typeParametersNumber > 0 + } class MockKotlinClassifierType(override val classifier: JavaClassifier) : JavaClassifierType { @@ -176,88 +204,39 @@ class MockKotlinClassifierType(override val classifier: JavaClassifier) : JavaCl } -private fun resolveSupertype(name: String, - classOrObject: KtClassOrObject, - javac: JavacWrapper): JavaClass? { - val nameParts = name.split(".") - val ktFile = classOrObject.containingKtFile +class MockKotlinField(private val property: KtProperty) : JavaField { + override val name: Name + get() = property.nameAsSafeName + override val annotations: Collection + get() = throw UnsupportedOperationException("Should not be called") + override val isDeprecatedInJavaDoc: Boolean + get() = throw UnsupportedOperationException("Should not be called") + override val isAbstract: Boolean + get() = throw UnsupportedOperationException("Should not be called") + override val isStatic: Boolean + get() = throw UnsupportedOperationException("Should not be called") + override val isFinal: Boolean + get() = throw UnsupportedOperationException("Should not be called") + override val visibility: Visibility + get() = throw UnsupportedOperationException("Should not be called") + override val containingClass: JavaClass + get() = throw UnsupportedOperationException("Should not be called") + override val isEnumEntry: Boolean + get() = throw UnsupportedOperationException("Should not be called") + override val type: JavaType + get() = throw UnsupportedOperationException("Should not be called") + override val initializerValue: Any? + get() { + if (!property.hasModifier(KtTokens.CONST_KEYWORD)) return null + val initializer = property.initializer ?: return null - tryToResolveInner(name, classOrObject, javac, nameParts)?.let { return it } - ktFile.tryToResolvePackageClass(name, javac, nameParts)?.let { return it } - tryToResolveByFqName(name, javac)?.let { return it } - ktFile.tryToResolveSingleTypeImport(name, javac, nameParts)?.let { return it } - ktFile.tryToResolveTypeImportOnDemand(name, javac, nameParts)?.let { return it } - tryToResolveInJavaLang(name, javac)?.let { return it } + return initializer.text.toIntOrNull() ?: initializer.text + } + override val hasConstantNotNullInitializer: Boolean + get() = throw UnsupportedOperationException("Should not be called") - return null + override fun findAnnotation(fqName: FqName) = throw UnsupportedOperationException("Should not be called") } -private fun tryToResolveInner(name: String, - classOrObject: KtClassOrObject, - javac: JavacWrapper, - nameParts: List) = - classOrObject.containingClassOrObject?.let { containingClass -> - containingClass.fqName?.let { - javac.findClass(it) ?: javac.getKotlinClassifier(it) - } - }?.findInner(name, javac, nameParts) - -private fun KtFile.tryToResolvePackageClass(name: String, - javac: JavacWrapper, - nameParts: List = emptyList()): JavaClass? { - return if (nameParts.size > 1) { - find(FqName("${packageFqName.asString()}.${nameParts.first()}"), javac, nameParts) - } - else { - javac.findClass(FqName("${packageFqName.asString()}.$name")) - ?: javac.getKotlinClassifier(FqName("${packageFqName.asString()}.$name")) - } -} - -private fun KtFile.tryToResolveSingleTypeImport(name: String, - javac: JavacWrapper, - nameParts: List = emptyList()): JavaClass? { - if (nameParts.size > 1) { - val foundImports = importDirectives.filter { it.text.endsWith(".${nameParts.first()}") } - foundImports.forEach { importDirective -> - importDirective.importedFqName?.let { importedFqName -> - find(importedFqName, javac, nameParts)?.let { importedClass -> - return importedClass - } - } - } - return null - } - else { - return importDirectives.find { importDirective -> - importDirective.text.endsWith(".$name") - }?.let { importDirective -> - importDirective.importedFqName?.let { fqName -> - javac.findClass(fqName) ?: javac.getKotlinClassifier(fqName) - } - } - } -} - -private fun KtFile.tryToResolveTypeImportOnDemand(name: String, - javac: JavacWrapper, - nameParts: List = emptyList()): JavaClass? { - val packagesWithAsterisk = importDirectives.filter { it.text.endsWith("*") } - - if (nameParts.size > 1) { - packagesWithAsterisk.forEach { importDirective -> - find(FqName("${importDirective.importedFqName?.asString()}.${nameParts.first()}"), - javac, - nameParts)?.let { return it } - } - return null - } - else { - packagesWithAsterisk.forEach { importDirective -> - val fqName = "${importDirective.importedFqName?.asString()}.$name".let(::FqName) - javac.findClass(fqName)?.let { return it } ?: javac.getKotlinClassifier(fqName)?.let { return it } - } - - return null - } -} \ No newline at end of file +private fun KtClassOrObject.computeClassId(): ClassId? = + containingClassOrObject?.computeClassId()?.createNestedClassId(nameAsSafeName) ?: fqName?.let { ClassId.topLevel(it) } \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinSupertypeResolver.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinSupertypeResolver.kt new file mode 100644 index 00000000000..088fafeb878 --- /dev/null +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/KotlinSupertypeResolver.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.javac + +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.psi.KtClassOrObject + +interface KotlinSupertypeResolver { + fun resolveSupertypes(classOrObject: KtClassOrObject): List +} \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/SymbolBasedClass.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/SymbolBasedClass.kt index 45ef3e17016..5ee89ed8752 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/SymbolBasedClass.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/SymbolBasedClass.kt @@ -31,6 +31,7 @@ import javax.lang.model.element.TypeElement import javax.lang.model.element.VariableElement import javax.lang.model.type.NoType import javax.lang.model.type.TypeKind +import javax.lang.model.type.TypeMirror import javax.tools.JavaFileObject class SymbolBasedClass( @@ -61,10 +62,11 @@ class SymbolBasedClass( get() = FqName(element.qualifiedName.toString()) override val supertypes: Collection - get() = element.interfaces.toMutableList() + get() = arrayListOf() .apply { element.superclass.takeIf { it !is NoType }?.let(this::add) } + .apply { addAll(element.interfaces) } .mapTo(arrayListOf()) { SymbolBasedClassifierType(it, javac) } .apply { if (isEmpty() && element.qualifiedName.toString() != CommonClassNames.JAVA_LANG_OBJECT) { @@ -97,9 +99,17 @@ class SymbolBasedClass( override val methods: Collection get() = element.enclosedElements - .filter { it.kind == ElementKind.METHOD } + .filter { it.kind == ElementKind.METHOD && !isEnumValuesOrValueOf(it as ExecutableElement)} .map { SymbolBasedMethod(it as ExecutableElement, javac) } + private fun isEnumValuesOrValueOf(method: ExecutableElement): Boolean { + return isEnum && when (method.simpleName.toString()) { + "values" -> method.parameters.isEmpty() + "valueOf" -> method.parameters.let { it.size == 1 && it.first().asType().toString() == "java.lang.String" } + else -> false + } + } + override val fields: Collection get() = element.enclosedElements .filter { it.kind.isField && Name.isValidIdentifier(it.simpleName.toString()) } diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedAnnotationArguments.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedAnnotationArguments.kt index 617ae8070ce..83230627023 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedAnnotationArguments.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedAnnotationArguments.kt @@ -32,7 +32,7 @@ sealed class SymbolBasedAnnotationArgument( companion object { fun create(value: Any, name: Name, javac: JavacWrapper): JavaAnnotationArgument = when (value) { is AnnotationMirror -> SymbolBasedAnnotationAsAnnotationArgument(value, name, javac) - is VariableElement -> SymbolBasedReferenceAnnotationArgument(value, javac) + is VariableElement -> SymbolBasedReferenceAnnotationArgument(value, name, javac) is TypeMirror -> SymbolBasedClassObjectAnnotationArgument(value, name, javac) is Collection<*> -> arrayAnnotationArguments(value, name, javac) is AnnotationValue -> create(value.value, name, javac) @@ -59,10 +59,11 @@ class SymbolBasedAnnotationAsAnnotationArgument( class SymbolBasedReferenceAnnotationArgument( val element: VariableElement, + name: Name, javac: JavacWrapper -) : SymbolBasedAnnotationArgument(Name.identifier(element.simpleName.toString()), javac), JavaEnumValueAnnotationArgument { +) : SymbolBasedAnnotationArgument(name, javac), JavaEnumValueAnnotationArgument { override val entryName: Name? - get() = Name.identifier(element.simpleName.toString()) + get() = Name.identifier(name) override fun resolve() = SymbolBasedField(element, javac) diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedTypes.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedTypes.kt index 4a29885d8ee..0361b5d9324 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedTypes.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/symbolBasedTypes.kt @@ -82,18 +82,29 @@ class SymbolBasedClassifierType( } override val typeArguments: List - get() = if (typeMirror.kind == TypeKind.DECLARED) { - (typeMirror as DeclaredType).typeArguments.map { create(it, javac) } - } - else { - emptyList() + get() { + if (typeMirror.kind != TypeKind.DECLARED) return emptyList() + + val arguments = arrayListOf() + var type = typeMirror as DeclaredType + var staticType = false + + while (!staticType) { + if (type.asElement().isStatic) { + staticType = true } + arguments.addAll(type.typeArguments.map { create(it, javac) }) + type = type.enclosingType as? DeclaredType ?: return arguments + } + + return arguments + } override val isRaw: Boolean get() = when { typeMirror !is DeclaredType -> false (typeMirror.asElement() as TypeElement).typeParameters.isEmpty() -> false - else -> typeMirror.typeArguments.isEmpty() + else -> typeMirror.typeArguments.isEmpty() || (typeMirror.asElement() as TypeElement).typeParameters.size != typeMirror.typeArguments.size } override val classifierQualifiedName: String diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/utils.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/utils.kt index f2fc7998d16..8203cf4a933 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/utils.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/symbols/utils.kt @@ -62,7 +62,7 @@ internal fun TypeElement.computeClassId(): ClassId? { internal fun ExecutableElement.valueParameters(javac: JavacWrapper): List = parameters.mapIndexed { index, parameter -> SymbolBasedValueParameter(parameter, - parameter.simpleName.toString(), + if (!parameter.simpleName.contentEquals("arg$index")) parameter.simpleName.toString() else "p$index", index == parameters.lastIndex && isVarArgs, javac) } diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/ClassifierResolver.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/ClassifierResolver.kt new file mode 100644 index 00000000000..fe598982819 --- /dev/null +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/ClassifierResolver.kt @@ -0,0 +1,348 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.javac.wrappers.trees + +import com.sun.source.tree.Tree +import com.sun.source.util.TreePath +import com.sun.tools.javac.tree.JCTree +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.javac.JavacWrapper +import org.jetbrains.kotlin.javac.MockKotlinClassifier +import org.jetbrains.kotlin.load.java.JavaVisibilities +import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.load.java.structure.JavaClassifier +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name + +class ClassifierResolver(private val javac: JavacWrapper) { + + private val cache = hashMapOf() + private val beingResolved = hashSetOf() + + fun resolve(treePath: TreePath): JavaClassifier? = with (treePath) { + if (cache.containsKey(leaf)) return cache[leaf] + if (treePath.leaf in beingResolved) return null + beingResolved(treePath.leaf) + + return tryToResolve().apply { + cache[leaf] = this + removeBeingResolved(treePath.leaf) + } + } + + // to avoid StackOverflow when there are cyclic dependencies + private fun beingResolved(tree: Tree) { + if (tree is JCTree.JCTypeApply) { + beingResolved(tree.clazz) + } + if (tree is JCTree.JCFieldAccess) { + beingResolved.add(tree) + beingResolved(tree.selected) + } + else beingResolved.add(tree) + } + + private fun removeBeingResolved(tree: Tree) { + if (tree is JCTree.JCTypeApply) { + beingResolved(tree.clazz) + } + if (tree is JCTree.JCFieldAccess) { + beingResolved.remove(tree) + beingResolved(tree.selected) + } + else beingResolved.remove(tree) + } + + private fun pathSegments(path: String): List { + val pathSegments = arrayListOf() + var numberOfBrackets = 0 + var builder = StringBuilder() + path.forEach { char -> + when (char) { + '<' -> numberOfBrackets++ + '>' -> numberOfBrackets-- + '.' -> { + if (numberOfBrackets == 0) { + pathSegments.add(builder.toString()) + builder = StringBuilder() + } + } + '@' -> {} + else -> if (numberOfBrackets == 0) builder.append(char) + } + } + + return pathSegments.apply { add(builder.toString()) } + } + + private fun TreePath.tryToResolve(): JavaClassifier? { + val pathSegments = pathSegments(leaf.toString()) + + return tryToGetTypeParameterFromMethod()?.let { return it } ?: + createResolutionScope(this).findClass(pathSegments.first(), pathSegments) + } + + private fun TreePath.tryToGetTypeParameterFromMethod(): TreeBasedTypeParameter? = + (find { it is JCTree.JCMethodDecl } as? JCTree.JCMethodDecl) + ?.typarams?.find { it.name.toString() == leaf.toString() } + ?.let { + TreeBasedTypeParameter(it, + javac.getTreePath(it, compilationUnit), + javac) + } + + private fun createResolutionScope(treePath: TreePath): Scope = CurrentClassAndInnerScope(javac, treePath) + +} + +private abstract class Scope(protected val javac: JavacWrapper, + protected val treePath: TreePath) { + + abstract val parent: Scope? + + abstract fun findClass(name: String, pathSegments: List): JavaClassifier? + + protected fun getJavaClassFromPathSegments(javaClass: JavaClass, + pathSegments: List) = + if (pathSegments.size == 1) { + javaClass + } + else { + javaClass.findInnerOrNested(pathSegments.drop(1)) + } + + protected fun findImport(pathSegments: List): JavaClass? { + pathSegments.forEachIndexed { index, _ -> + if (index == pathSegments.lastIndex) return null + val packageFqName = pathSegments.dropLast(index + 1).joinToString(separator = ".") + findPackage(packageFqName)?.let { pack -> + val className = pathSegments.takeLast(index + 1) + return findJavaOrKotlinClass(ClassId(pack, Name.identifier(className.first())))?.let { javaClass -> + getJavaClassFromPathSegments(javaClass, className) + } + } + } + + return null + } + + protected fun findJavaOrKotlinClass(classId: ClassId) = javac.findClass(classId) ?: javac.getKotlinClassifier(classId) + + protected fun JavaClass.findInnerOrNested(name: Name, checkedSupertypes: HashSet = hashSetOf()): JavaClass? { + findVisibleInnerOrNestedClass(name)?.let { + checkedSupertypes.addAll(collectAllSupertypes()) + return it + } + + return supertypes + .mapNotNull { + (it.classifier as? JavaClass)?.let { supertype -> + if (supertype !in checkedSupertypes) { + supertype.findInnerOrNested(name, checkedSupertypes) + } else null + } + }.singleOrNull() + } + + protected fun findPackage(packageName: String): FqName? { + val fqName = if (packageName.isNotBlank()) FqName(packageName) else FqName.ROOT + javac.hasKotlinPackage(fqName)?.let { return it } + + return javac.findPackage(fqName)?.fqName + } + + private fun JavaClass.findVisibleInnerOrNestedClass(name: Name) = findInnerClass(name)?.let { innerOrNestedClass -> + when (innerOrNestedClass.visibility) { + Visibilities.PRIVATE -> null + JavaVisibilities.PACKAGE_VISIBILITY -> { + val classId = (innerOrNestedClass as? MockKotlinClassifier)?.classId ?: innerOrNestedClass.computeClassId() + if (classId?.packageFqName?.asString() == (treePath.compilationUnit.packageName?.toString() ?: "")) innerOrNestedClass else null + } + else -> innerOrNestedClass + } + } + + private fun JavaClass.collectAllSupertypes(): Set = + hashSetOf(this).apply { + supertypes.mapNotNull { it.classifier as? JavaClass }.forEach { addAll(it.collectAllSupertypes()) } + } + + private fun JavaClass.findInnerOrNested(pathSegments: List): JavaClass? = + pathSegments.fold(this) { javaClass, it -> javaClass.findInnerOrNested(Name.identifier(it)) ?: return null } + +} + +private class GlobalScope(javac: JavacWrapper, treePath: TreePath) : Scope(javac, treePath) { + + override val parent: Scope? + get() = null + + override fun findClass(name: String, pathSegments: List): JavaClass? { + findByFqName(pathSegments)?.let { return it } + + return findJavaOrKotlinClass(classId("java.lang", name))?.let { javaClass -> + getJavaClassFromPathSegments(javaClass, pathSegments) + } + } + + private fun findByFqName(pathSegments: List): JavaClass? { + pathSegments.forEachIndexed { index, _ -> + if (index != 0) { + val packageFqName = pathSegments.take(index).joinToString(separator = ".") + findPackage(packageFqName)?.let { pack -> + val className = pathSegments.drop(index) + findJavaOrKotlinClass(ClassId(pack, Name.identifier(className.first())))?.let { javaClass -> + return getJavaClassFromPathSegments(javaClass, className) + } + } + } + } + + // try to find in + return findJavaOrKotlinClass(classId("", pathSegments.first()))?.let { javaClass -> + getJavaClassFromPathSegments(javaClass, pathSegments) + } + } + +} + +private class ImportOnDemandScope(javac: JavacWrapper, + treePath: TreePath) : Scope(javac, treePath) { + + override val parent: Scope + get() = GlobalScope(javac, treePath) + + override fun findClass(name: String, pathSegments: List): JavaClassifier? { + asteriskImports() + .mapNotNullTo(hashSetOf()) { findImport("$it$name".split(".")) } + .takeIf { it.isNotEmpty() } + ?.let { + return it.singleOrNull()?.let { javaClass -> + getJavaClassFromPathSegments(javaClass, pathSegments) + } + } + + return parent.findClass(name, pathSegments) + } + + private fun asteriskImports() = + treePath.compilationUnit.imports + .mapNotNull { + val fqName = it.qualifiedIdentifier.toString() + if (fqName.endsWith("*")) { + fqName.dropLast(1) + } + else null + } + +} + +private class PackageScope(javac: JavacWrapper, + treePath: TreePath) : Scope(javac, treePath) { + + override val parent: Scope + get() = ImportOnDemandScope(javac, treePath) + + override fun findClass(name: String, pathSegments: List): JavaClassifier? { + findJavaOrKotlinClass(classId(treePath.compilationUnit.packageName?.toString() ?: "", name)) + ?.let { javaClass -> + return getJavaClassFromPathSegments(javaClass, pathSegments) + } + + return parent.findClass(name, pathSegments) + } + +} + +private class SingleTypeImportScope(javac: JavacWrapper, + treePath: TreePath) : Scope(javac, treePath) { + + override val parent: Scope + get() = PackageScope(javac, treePath) + + override fun findClass(name: String, pathSegments: List): JavaClassifier? { + val imports = imports(name).toSet().takeIf { it.isNotEmpty() } + ?: return parent.findClass(name, pathSegments) + + imports.singleOrNull() ?: return null + + return findImport(imports.first().split(".")) + ?.let { javaClass -> getJavaClassFromPathSegments(javaClass, pathSegments) } + } + + private fun imports(firstSegment: String) = + (treePath.compilationUnit as JCTree.JCCompilationUnit).imports + .mapNotNull { + val fqName = it.qualifiedIdentifier.toString() + if (fqName.endsWith(".$firstSegment")) { + fqName + } + else null + } + +} + +private class CurrentClassAndInnerScope(javac: JavacWrapper, + treePath: TreePath) : Scope(javac, treePath) { + + override val parent: Scope + get() = SingleTypeImportScope(javac, treePath) + + override fun findClass(name: String, pathSegments: List): JavaClassifier? { + val identifier = Name.identifier(name) + treePath.enclosingClasses.forEach { + (it as? TreeBasedClass)?.typeParameters + ?.find { typeParameter -> typeParameter.name == identifier } + ?.let { typeParameter -> return typeParameter } + + it.findInnerOrNested(identifier)?.let { javaClass -> return getJavaClassFromPathSegments(javaClass, pathSegments) } + + if (it.name == identifier && pathSegments.size == 1) return it + } + + return parent.findClass(name, pathSegments) + } + + private val TreePath.enclosingClasses: List + get() { + val outerClasses = filterIsInstance() + .dropWhile { it.extending == leaf || leaf in it.implementing } + .asReversed() + .map { it.simpleName.toString() } + + val packageName = compilationUnit.packageName?.toString() ?: "" + val outermostClassName = outerClasses.firstOrNull() ?: return emptyList() + + val outermostClassId = classId(packageName, outermostClassName) + var outermostClass = javac.findClass(outermostClassId) ?: return emptyList() + + val classes = arrayListOf() + classes.add(outermostClass) + + for (it in outerClasses.drop(1)) { + outermostClass = outermostClass.findInnerClass(Name.identifier(it)) + ?: throw AssertionError("Couldn't find a class ($it) that is surely defined in ${outermostClass.fqName?.asString()}") + classes.add(outermostClass) + } + + return classes.reversed() + } + +} + +fun classId(packageName: String = "", className: String) = ClassId(FqName(packageName), Name.identifier(className)) \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedAnnotation.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedAnnotation.kt index 0bdf7f699eb..40538c8ef9d 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedAnnotation.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedAnnotation.kt @@ -16,38 +16,137 @@ package org.jetbrains.kotlin.javac.wrappers.trees -import com.sun.source.tree.CompilationUnitTree import com.sun.source.util.TreePath import com.sun.tools.javac.tree.JCTree import org.jetbrains.kotlin.javac.JavacWrapper -import org.jetbrains.kotlin.load.java.structure.JavaAnnotation -import org.jetbrains.kotlin.load.java.structure.JavaAnnotationArgument -import org.jetbrains.kotlin.load.java.structure.JavaClass -import org.jetbrains.kotlin.load.java.structure.JavaElement +import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name class TreeBasedAnnotation( - private val annotation: JCTree.JCAnnotation, - private val compilationUnit: CompilationUnitTree, - private val javac: JavacWrapper + val annotation: JCTree.JCAnnotation, + val treePath: TreePath, + val javac: JavacWrapper ) : JavaElement, JavaAnnotation { - constructor( - annotation: JCTree.JCAnnotation, - treePath: TreePath, - javac: JavacWrapper - ) : this(annotation, treePath.compilationUnit, javac) - override val arguments: Collection - get() = annotation.arguments.map { TreeBasedAnnotationArgument(Name.identifier(it.toString())) } + get() = createAnnotationArguments(this, javac) override val classId: ClassId? - get() = resolve()?.computeClassId() + get() = resolve()?.computeClassId() ?: ClassId.topLevel(FqName(annotation.annotationType.toString().substringAfter("@"))) override fun resolve() = - javac.resolve(TreePath.getPath(compilationUnit, annotation.annotationType)) as? JavaClass + javac.resolve(TreePath.getPath(treePath.compilationUnit, annotation.annotationType)) as? JavaClass } -class TreeBasedAnnotationArgument(override val name: Name) : JavaAnnotationArgument, JavaElement +sealed class TreeBasedAnnotationArgument(override val name: Name, + val javac: JavacWrapper) : JavaAnnotationArgument, JavaElement + +class TreeBasedLiteralAnnotationArgument(name: Name, + override val value: Any?, + javac: JavacWrapper) : TreeBasedAnnotationArgument(name, javac), JavaLiteralAnnotationArgument + +class TreeBasedReferenceAnnotationArgument(name: Name, + private val treePath: TreePath, + private val field: JCTree.JCFieldAccess, + javac: JavacWrapper) : TreeBasedAnnotationArgument(name, javac), JavaEnumValueAnnotationArgument { + + override fun resolve(): JavaField? { + val newTreePath = javac.getTreePath(field.selected, treePath.compilationUnit) + val javaClass = javac.resolve(newTreePath) as? JavaClass ?: return null + val fieldName = field.name.toString().let { Name.identifier(it) } + + return javaClass.fields.find { it.name == fieldName } + } + +} + +class TreeBasedArrayAnnotationArgument(val args: List, + name: Name, + javac: JavacWrapper): TreeBasedAnnotationArgument(name, javac), JavaArrayAnnotationArgument { + override fun getElements() = args + +} + +class TreeBasedJavaClassObjectAnnotationArgument(private val type: JCTree.JCExpression, + name: Name, + private val treePath: TreePath, + javac: JavacWrapper): TreeBasedAnnotationArgument(name, javac), JavaClassObjectAnnotationArgument { + + override fun getReferencedType(): JavaType = + TreeBasedType.create(type, javac.getTreePath(type, treePath.compilationUnit), javac, emptyList()) + +} + +class TreeBasedAnnotationAsAnnotationArgument(private val annotation: JCTree.JCAnnotation, + name: Name, + private val treePath: TreePath, + javac: JavacWrapper): TreeBasedAnnotationArgument(name, javac), JavaAnnotationAsAnnotationArgument { + override fun getAnnotation(): JavaAnnotation = + TreeBasedAnnotation(annotation, javac.getTreePath(annotation, treePath.compilationUnit), javac ) + +} + +private fun createAnnotationArguments(annotation: TreeBasedAnnotation, + javac: JavacWrapper): Collection { + val arguments = annotation.annotation.arguments + val javaClass = annotation.resolve() ?: return emptyList() + val methods = javaClass.methods + + if (arguments.size != methods.size) return emptyList() + + return methods.mapIndexedNotNull { index, it -> + createAnnotationArgument(arguments[index], it.name, annotation.treePath, javac, annotation) + } +} + +private fun createAnnotationArgument(argument: JCTree.JCExpression, + name: Name, + treePath: TreePath, + javac: JavacWrapper, + annotation: TreeBasedAnnotation): JavaAnnotationArgument? = + when (argument) { + is JCTree.JCLiteral -> TreeBasedLiteralAnnotationArgument(name, argument.value, javac) + is JCTree.JCFieldAccess -> { + if (argument.name.contentEquals("class")) { + TreeBasedJavaClassObjectAnnotationArgument(argument.selected, name, treePath, javac) + } else { + TreeBasedReferenceAnnotationArgument(name, treePath, argument, javac) + } + } + is JCTree.JCAssign -> createAnnotationArgument(argument.rhs, name, treePath, javac, annotation) + is JCTree.JCNewArray -> arrayAnnotationArguments(argument.elems, name, treePath, javac, annotation) + is JCTree.JCAnnotation -> TreeBasedAnnotationAsAnnotationArgument(argument, name, treePath, javac) + is JCTree.JCParens -> createAnnotationArgument(argument.expr, name, treePath, javac, annotation) + is JCTree.JCBinary -> resolveArgumentValue(argument, annotation, name, treePath, javac) + is JCTree.JCUnary -> resolveArgumentValue(argument, annotation, name, treePath, javac) + else -> null + } + +private fun resolveArgumentValue(argument: JCTree.JCExpression, + annotation: TreeBasedAnnotation, + name: Name, + treePath: TreePath, + javac: JavacWrapper): JavaAnnotationArgument? { + val containingAnnotation = annotation.resolve() + val type = containingAnnotation?.methods?.find { it.name == name }?.returnType ?: return null + val calculator = ValueCalculator(containingAnnotation, javac, treePath, type) + + return calculator.getValue(argument)?.let { TreeBasedLiteralAnnotationArgument(name, it, javac) } +} + +private fun arrayAnnotationArguments(values: List, + name: Name, + treePath: TreePath, + javac: JavacWrapper, + annotation: TreeBasedAnnotation): JavaArrayAnnotationArgument = + values.mapNotNull { + if (it is JCTree.JCNewArray) { + arrayAnnotationArguments(it.elems, name, treePath, javac, annotation) + } + else { + createAnnotationArgument(it, name, treePath, javac, annotation) + } + }.let { TreeBasedArrayAnnotationArgument(it, name, javac) } \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedClass.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedClass.kt index 9d7601e1741..17b363bb103 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedClass.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedClass.kt @@ -50,54 +50,52 @@ class TreeBasedClass( annotations.find { it.classId?.asSingleFqName() == fqName } override val isDeprecatedInJavaDoc: Boolean - get() = false + get() = javac.isDeprecatedInJavaDoc(treePath) override val isAbstract: Boolean - get() = tree.modifiers.isAbstract || (isAnnotationType && methods.any { it.isAbstract }) + get() = tree.modifiers.isAbstract || ((isAnnotationType || isEnum) && methods.any { it.isAbstract }) override val isStatic: Boolean - get() = (outerClass?.isInterface ?: false) || tree.modifiers.isStatic + get() = isEnum || isInterface || (outerClass?.isInterface ?: false) || tree.modifiers.isStatic override val isFinal: Boolean - get() = tree.modifiers.isFinal + get() = isEnum || tree.modifiers.isFinal override val visibility: Visibility - get() = if (outerClass?.isInterface ?: false) PUBLIC else tree.modifiers.visibility + get() = if (outerClass?.isInterface == true) PUBLIC else tree.modifiers.visibility override val typeParameters: List get() = tree.typeParameters.map { parameter -> TreeBasedTypeParameter(parameter, TreePath(treePath, parameter), javac) } - override val fqName: FqName = - treePath.reversed() - .filterIsInstance() - .joinToString( - separator = ".", - prefix = "${treePath.compilationUnit.packageName}.", - transform = JCTree.JCClassDecl::name - ) - .let(::FqName) + override val fqName: FqName + get() = treePath.reversed() + .filterIsInstance() + .joinToString( + separator = ".", + transform = JCTree.JCClassDecl::name + ) + .let { treePath.compilationUnit.packageName?.let { packageName -> FqName("$packageName.$it") } ?: FqName.topLevel(Name.identifier(it))} override val supertypes: Collection - get() = arrayListOf().apply { - fun JCTree.mapToJavaClassifierType() = when { - this is JCTree.JCTypeApply -> TreeBasedGenericClassifierType(this, TreePath(treePath, this), javac) - this is JCTree.JCExpression -> TreeBasedNonGenericClassifierType(this, TreePath(treePath, this), javac) - else -> null - } - + get() = arrayListOf().also { list -> if (isEnum) { - javac.JAVA_LANG_ENUM?.let(this::add) + createEnumSupertype(this, javac).let { list.add(it) } } else if (isAnnotationType) { - javac.JAVA_LANG_ANNOTATION_ANNOTATION?.let(this::add) + javac.JAVA_LANG_ANNOTATION_ANNOTATION?.let { list.add(it) } } - tree.implementing?.mapNotNull { it.mapToJavaClassifierType() }?.let(this::addAll) - tree.extending?.let { it.mapToJavaClassifierType()?.let(this::add) } + tree.extending?.let { + (TreeBasedType.create(it, javac.getTreePath(it, treePath.compilationUnit), javac, emptyList()) as? JavaClassifierType) + ?.let { list.add(it) } + } + tree.implementing?.mapNotNull { + TreeBasedType.create(it, javac.getTreePath(it, treePath.compilationUnit), javac, emptyList()) as? JavaClassifierType + }?.let { list.addAll(it) } - if (isEmpty()) { - javac.JAVA_LANG_OBJECT?.let(this::add) + if (list.isEmpty()) { + javac.JAVA_LANG_OBJECT?.let { list.add(it) } } } @@ -155,3 +153,44 @@ class TreeBasedClass( override fun findInnerClass(name: Name) = innerClasses[name] } + +private fun createEnumSupertype(javaClass: JavaClass, + javac: JavacWrapper) = object : JavaClassifierType { + override val classifier: JavaClassifier? + get() = javac.JAVA_LANG_ENUM + + override val typeArguments: List + get() = listOf(TypeArgument()) + + override val isRaw: Boolean + get() = false + override val annotations: Collection + get() = emptyList() + override val classifierQualifiedName: String + get() = (classifier as? JavaClass)?.fqName?.asString() ?: "" + override val presentableText: String + get() = classifierQualifiedName + override val isDeprecatedInJavaDoc: Boolean + get() = false + override fun findAnnotation(fqName: FqName) = null + + private inner class TypeArgument : JavaClassifierType { + override val classifier: JavaClassifier? + get() = javaClass + override val typeArguments: List + get() = emptyList() + override val isRaw: Boolean + get() = false + override val annotations: Collection + get() = emptyList() + override val classifierQualifiedName: String + get() = javaClass.fqName!!.asString() + override val presentableText: String + get() = classifierQualifiedName + override val isDeprecatedInJavaDoc: Boolean + get() = false + override fun findAnnotation(fqName: FqName) = null + + } + +} diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedField.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedField.kt index aaf350187a7..af806fc6814 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedField.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedField.kt @@ -18,12 +18,15 @@ package org.jetbrains.kotlin.javac.wrappers.trees import com.sun.source.util.TreePath import com.sun.tools.javac.code.Flags +import com.sun.tools.javac.code.TypeTag import com.sun.tools.javac.tree.JCTree +import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.javac.JavacWrapper import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.load.java.structure.JavaField +import org.jetbrains.kotlin.load.java.structure.JavaPrimitiveType import org.jetbrains.kotlin.load.java.structure.JavaType import org.jetbrains.kotlin.name.Name @@ -53,19 +56,16 @@ class TreeBasedField( get() = tree.modifiers.flags and Flags.ENUM.toLong() != 0L override val type: JavaType - get() = TreeBasedType.create(tree.getType(), treePath, javac) + get() = TreeBasedType.create(tree.getType(), treePath, javac, annotations) override val initializerValue: Any? get() = tree.init?.let { initExpr -> - if (hasConstantNotNullInitializer && initExpr is JCTree.JCLiteral) { - initExpr.value - } else { - null - } + if (hasConstantNotNullInitializer) ValueCalculator(containingClass, javac, treePath, type).getValue(initExpr) else null } override val hasConstantNotNullInitializer: Boolean get() = tree.init?.let { + if (it is JCTree.JCLiteral && it.value == null) return false val type = this.type isFinal && ((type is TreeBasedPrimitiveType) || @@ -73,4 +73,104 @@ class TreeBasedField( type.classifierQualifiedName == "java.lang.String")) } ?: false +} + +class ValueCalculator(private val containingClass: JavaClass, + private val javac: JavacWrapper, + private val treePath: TreePath, + private val type: JavaType) { + fun getValue(expr: JCTree.JCExpression): Any? { + return when (expr) { + is JCTree.JCLiteral -> { + if (expr.typetag == TypeTag.BOOLEAN) { + expr.value != 0 + } + else expr.value + } + is JCTree.JCIdent -> containingClass.fields + .find { it.name == expr.name.toString().let { Name.identifier(it) } } + ?.initializerValue + is JCTree.JCFieldAccess -> fieldAccessValue(expr) + is JCTree.JCBinary -> binaryInitializerValue(expr) + is JCTree.JCParens -> getValue(expr.expr) + is JCTree.JCUnary -> unaryInitializerValue(expr) + else -> null + } + } + + private fun fieldAccessValue(value: JCTree.JCFieldAccess): Any? { + val newTreePath = javac.getTreePath(value.selected, treePath.compilationUnit) + val javaClass = javac.resolve(newTreePath) as? JavaClass ?: return null + val fieldName = value.name.toString().let { Name.identifier(it) } + + return javaClass.fields + .find { it.name == fieldName } + ?.initializerValue + } + + private fun unaryInitializerValue(value: JCTree.JCUnary): Any? { + val argValue = getValue(value.arg) + return when (value.tag) { + JCTree.Tag.COMPL -> (argValue as? Int)?.inv() + JCTree.Tag.NOT -> (argValue as? Boolean)?.let { !it } + else -> null + } + } + + private fun binaryInitializerValue(value: JCTree.JCBinary): Any? { + val lhsValue = getValue(value.lhs) ?: return null + val rhsValue = getValue(value.rhs) ?: return null + + return calculateValue(lhsValue, rhsValue, value.tag) + } + + private fun calculateValue(lhsValue: Any?, rhsValue: Any?, opcode: JCTree.Tag): Any? { + if (lhsValue is String && opcode == JCTree.Tag.PLUS) return lhsValue + rhsValue + + if (lhsValue is Boolean && rhsValue is Boolean) { + return when (opcode) { + JCTree.Tag.AND -> lhsValue && rhsValue + JCTree.Tag.OR -> lhsValue || rhsValue + JCTree.Tag.EQ -> lhsValue == rhsValue + JCTree.Tag.NE -> lhsValue != rhsValue + else -> null + } + } + + val l = (lhsValue as? Number)?.toInt() ?: return null + val r = (rhsValue as? Number)?.toInt() ?: return null + return when (opcode) { + JCTree.Tag.PLUS -> getExpressionType(l + r) + JCTree.Tag.MINUS -> getExpressionType(l - r) + JCTree.Tag.MUL -> getExpressionType(l * r) + JCTree.Tag.DIV -> getExpressionType(l / r) + JCTree.Tag.MOD -> getExpressionType(l % r) + JCTree.Tag.SR -> getExpressionType(l shr r) + JCTree.Tag.SL -> getExpressionType(l shl r) + JCTree.Tag.BITAND -> getExpressionType(l and r) + JCTree.Tag.BITOR -> getExpressionType(l or r) + JCTree.Tag.BITXOR -> getExpressionType(l xor r) + JCTree.Tag.USR -> getExpressionType(l ushr r) + JCTree.Tag.EQ -> l == r + JCTree.Tag.NE -> l != r + JCTree.Tag.LT -> l < r + JCTree.Tag.LE -> l <= r + JCTree.Tag.GT -> l > r + JCTree.Tag.GE -> l >= r + else -> null + } + } + + private fun getExpressionType(expression: Int): Any? { + val type = type as? JavaPrimitiveType ?: return null + return when (type.type) { + PrimitiveType.DOUBLE -> expression.toDouble() + PrimitiveType.INT -> expression + PrimitiveType.FLOAT -> expression.toFloat() + PrimitiveType.LONG -> expression.toLong() + PrimitiveType.SHORT -> expression.toShort() + PrimitiveType.BYTE -> expression.toByte() + else -> null + } + } } \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMember.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMember.kt index af24bc238b3..8107dcff33d 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMember.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMember.kt @@ -32,7 +32,7 @@ abstract class TreeBasedMember( ) : TreeBasedElement(tree, treePath, javac), JavaMember { override val isDeprecatedInJavaDoc: Boolean - get() = false + get() = javac.isDeprecatedInJavaDoc(treePath) override val annotations: Collection by lazy { tree.annotations().map { TreeBasedAnnotation(it, treePath, javac) } diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMethod.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMethod.kt index 0f4147cf1d7..2a3ca3fd0c4 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMethod.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedMethod.kt @@ -53,7 +53,7 @@ class TreeBasedMethod( get() = tree.parameters.map { TreeBasedValueParameter(it, TreePath(treePath, it), javac) } override val returnType: JavaType - get() = TreeBasedType.create(tree.returnType, treePath, javac) + get() = TreeBasedType.create(tree.returnType, treePath, javac, annotations) override val hasAnnotationParameterDefaultValue: Boolean get() = tree.defaultValue != null diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedTypeParameter.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedTypeParameter.kt index 05e1f66c9e5..530c022b594 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedTypeParameter.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedTypeParameter.kt @@ -42,15 +42,22 @@ class TreeBasedTypeParameter( annotations.firstOrNull { it.classId?.asSingleFqName() == fqName } override val isDeprecatedInJavaDoc: Boolean - get() = false + get() = javac.isDeprecatedInJavaDoc(treePath) override val upperBounds: Collection get() = tree.bounds.mapNotNull { - when (it) { - is JCTree.JCTypeApply -> TreeBasedGenericClassifierType(it, TreePath(treePath, it), javac) - is JCTree.JCIdent -> TreeBasedNonGenericClassifierType(it, TreePath(treePath, it), javac) - else -> null - } + TreeBasedType.create(it, TreePath(treePath, it), javac, emptyList()) as? JavaClassifierType } + override fun equals(other: Any?): Boolean { + if (other !is TreeBasedTypeParameter) return false + return other.name == name && other.upperBounds == upperBounds + } + + override fun hashCode(): Int { + var result = name.hashCode() + upperBounds.forEach { result = 37 * result + it.hashCode() } + return result + } + } \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedValueParameter.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedValueParameter.kt index 5c490cae47e..647f1fb364e 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedValueParameter.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/TreeBasedValueParameter.kt @@ -40,13 +40,13 @@ class TreeBasedValueParameter( annotations.find { it.classId?.asSingleFqName() == fqName } override val isDeprecatedInJavaDoc: Boolean - get() = false + get() = javac.isDeprecatedInJavaDoc(treePath) override val name: Name get() = Name.identifier(tree.name.toString()) override val type: JavaType - get() = TreeBasedType.create(tree.getType(), treePath, javac) + get() = TreeBasedType.create(tree.getType(), treePath, javac, annotations) override val isVararg: Boolean get() = tree.modifiers.flags and Flags.VARARGS != 0L diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/resolve.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/resolve.kt deleted file mode 100644 index 620623aad53..00000000000 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/resolve.kt +++ /dev/null @@ -1,193 +0,0 @@ -/* - * Copyright 2010-2017 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.javac.wrappers.trees - -import com.sun.source.tree.Tree -import com.sun.source.util.TreePath -import com.sun.tools.javac.tree.JCTree -import org.jetbrains.kotlin.javac.JavacWrapper -import org.jetbrains.kotlin.load.java.structure.JavaClass -import org.jetbrains.kotlin.load.java.structure.JavaClassifier -import org.jetbrains.kotlin.name.FqName - -class TreePathResolverCache(private val javac: JavacWrapper) { - - private val cache = hashMapOf() - - fun resolve(treePath: TreePath): JavaClassifier? = with(treePath) { - if (cache.containsKey(leaf)) return cache[leaf] - - return tryToGetClassifier().apply { cache[leaf] = this } - } - - private fun TreePath.tryToGetClassifier(): JavaClassifier? { - val name = leaf.toString().substringBefore("<").substringAfter("@") - val nameParts = name.split(".") - - with(compilationUnit as JCTree.JCCompilationUnit) { - tryToResolveInner(name, javac, nameParts)?.let { return it } - tryToResolvePackageClass(name, javac, nameParts)?.let { return it } - tryToResolveByFqName(name, javac)?.let { return it } - tryToResolveSingleTypeImport(name, javac, nameParts)?.let { return it } - tryToResolveTypeImportOnDemand(name, javac, nameParts)?.let { return it } - tryToResolveInJavaLang(name, javac)?.let { return it } - } - - return tryToResolveTypeParameter(javac) - } - - private fun TreePath.tryToResolveInner( - name: String, - javac: JavacWrapper, - nameParts: List = emptyList() - ): JavaClass? = findEnclosingClasses(javac)?.forEach { javaClass -> - javaClass.findInner(name, javac, nameParts)?.let { inner -> return inner } - }.let { return null } - - private fun TreePath.findEnclosingClasses(javac: JavacWrapper) = - filterIsInstance() - .filter { it.extending != leaf && !it.implementing.contains(leaf) } - .reversed() - .joinToString(separator = ".", prefix = "${compilationUnit.packageName}.") { it.simpleName } - .let { javac.findClass(FqName(it)) } - ?.let { - arrayListOf(it).apply { - var enclosingClass = it.outerClass - while (enclosingClass != null) { - add(enclosingClass) - enclosingClass = enclosingClass.outerClass - } - } - } - - private fun JCTree.JCCompilationUnit.tryToResolveSingleTypeImport( - name: String, - javac: JavacWrapper, - nameParts: List = emptyList() - ): JavaClass? { - nameParts.size.takeIf { it > 1 }?.let { - imports.filter { it.qualifiedIdentifier.toString().endsWith(".${nameParts.first()}") } - .forEach { import -> - find(FqName("${import.qualifiedIdentifier}"), javac, nameParts)?.let { javaClass -> - return javaClass - } - } - .let { return null } - } - - return imports - .find { it.qualifiedIdentifier.toString().endsWith(".$name") } - ?.let { import -> - FqName(import.qualifiedIdentifier.toString()).let { fqName -> - javac.findClass(fqName) ?: javac.getKotlinClassifier(fqName) - } - } - } - - private fun JCTree.JCCompilationUnit.tryToResolvePackageClass( - name: String, - javac: JavacWrapper, - nameParts: List = emptyList() - ): JavaClass? { - return nameParts.size.takeIf { it > 1 }?.let { - find(FqName("$packageName.${nameParts.first()}"), javac, nameParts) - } - ?: javac.findClass(FqName("$packageName.$name")) - ?: javac.getKotlinClassifier(FqName("$packageName.$name")) - } - - private fun JCTree.JCCompilationUnit.tryToResolveTypeImportOnDemand( - name: String, - javac: JavacWrapper, - nameParts: List = emptyList() - ): JavaClass? { - with(imports.filter { it.qualifiedIdentifier.toString().endsWith("*") }) { - nameParts.size.takeIf { it > 1 } - ?.let { - forEach { pack -> - find(FqName("${pack.qualifiedIdentifier.toString().substringBefore("*")}${nameParts.first()}"), - javac, - nameParts)?.let { return it } - }.let { return null } - } - - this.forEach { - val fqName = "${it.qualifiedIdentifier.toString().substringBefore("*")}$name".let(::FqName) - (javac.findClass(fqName) ?: javac.getKotlinClassifier(fqName))?.let { return it } - }.let { return null } - } - } - - private fun TreePath.tryToResolveTypeParameter(javac: JavacWrapper) = - flatMap { - when (it) { - is JCTree.JCClassDecl -> it.typarams - is JCTree.JCMethodDecl -> it.typarams - else -> emptyList() - } - } - .find { it.toString().substringBefore(" ") == leaf.toString() } - ?.let { - TreeBasedTypeParameter(it, - javac.getTreePath(it, compilationUnit), - javac) - } - -} - -fun JavaClass.findInner(name: String, - javac: JavacWrapper, - nameParts: List = emptyList()) : JavaClass? { - nameParts.size.takeIf { it > 1 }?.let { - return find(FqName("${fqName!!.asString()}.${nameParts[0]}"), javac, nameParts) - } - - if (name == this.fqName?.shortName()?.asString()) return this - - with(FqName("${fqName!!.asString()}.$name")) { - javac.findClass(this)?.let { return it } - javac.getKotlinClassifier(this)?.let { return it } - } - - supertypes.mapNotNull { it.classifier as? JavaClass } - .forEach { javaClass -> - javaClass.findInner(name, javac)?.let { inner -> return inner } - }.let { return null } -} - -fun tryToResolveByFqName(name: String, - javac: JavacWrapper) = with(FqName(name)) { - javac.findClass(this) ?: javac.getKotlinClassifier(this) -} - -fun tryToResolveInJavaLang(name: String, - javac: JavacWrapper) = javac.findClass(FqName("java.lang.$name")) - - -fun find(fqName: FqName, - javac: JavacWrapper, - nameParts: List): JavaClass? { - val initial = with(fqName) { - javac.findClass(this) - ?: javac.getKotlinClassifier(this) - ?: return null - } - - nameParts.drop(1).fold(initial) { - javaClass, namePart -> javaClass.findInner(namePart, javac) ?: return null - }.let { return it } -} \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/treeBasedTypes.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/treeBasedTypes.kt index 588576c3179..97825c47c36 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/treeBasedTypes.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/treeBasedTypes.kt @@ -30,23 +30,31 @@ import javax.lang.model.type.TypeKind abstract class TreeBasedType( val tree: T, val treePath: TreePath, - val javac: JavacWrapper + val javac: JavacWrapper, + override val annotations: Collection ) : JavaType, JavaAnnotationOwner { companion object { - fun create(tree: Type, treePath: TreePath, javac: JavacWrapper) = when (tree) { - is JCTree.JCPrimitiveTypeTree -> TreeBasedPrimitiveType(tree, TreePath(treePath, tree), javac) - is JCTree.JCArrayTypeTree -> TreeBasedArrayType(tree, TreePath(treePath, tree), javac) - is JCTree.JCWildcard -> TreeBasedWildcardType(tree, TreePath(treePath, tree), javac) - is JCTree.JCTypeApply -> TreeBasedGenericClassifierType(tree, TreePath(treePath, tree), javac) - is JCTree.JCExpression -> TreeBasedNonGenericClassifierType(tree, TreePath(treePath, tree), javac) - else -> throw UnsupportedOperationException("Unsupported type: $tree") + fun create(tree: JCTree, treePath: TreePath, + javac: JavacWrapper, annotations: Collection): JavaType { + val applicableAnnotations = annotations.filterTypeAnnotations() + return when (tree) { + is JCTree.JCPrimitiveTypeTree -> TreeBasedPrimitiveType(tree, javac.getTreePath(tree, treePath.compilationUnit), javac, applicableAnnotations) + is JCTree.JCArrayTypeTree -> TreeBasedArrayType(tree, javac.getTreePath(tree, treePath.compilationUnit), javac, applicableAnnotations) + is JCTree.JCWildcard -> TreeBasedWildcardType(tree, javac.getTreePath(tree, treePath.compilationUnit), javac, applicableAnnotations) + is JCTree.JCTypeApply -> TreeBasedGenericClassifierType(tree, javac.getTreePath(tree, treePath.compilationUnit), javac, applicableAnnotations) + is JCTree.JCAnnotatedType -> { + val underlyingType = tree.underlyingType + val newAnnotations = tree.annotations + .map { TreeBasedAnnotation(it, javac.getTreePath(it, treePath.compilationUnit), javac) } + create(underlyingType, javac.getTreePath(underlyingType, treePath.compilationUnit), javac, newAnnotations) + } + is JCTree.JCExpression -> TreeBasedNonGenericClassifierType(tree, javac.getTreePath(tree, treePath.compilationUnit), javac, applicableAnnotations) + else -> throw UnsupportedOperationException("Unsupported type: $tree") + } } } - override val annotations: Collection - get() = emptyList() - override val isDeprecatedInJavaDoc: Boolean get() = false @@ -63,8 +71,9 @@ abstract class TreeBasedType( class TreeBasedPrimitiveType( tree: JCTree.JCPrimitiveTypeTree, treePath: TreePath, - javac: JavacWrapper -) : TreeBasedType(tree, treePath, javac), JavaPrimitiveType { + javac: JavacWrapper, + annotations: Collection +) : TreeBasedType(tree, treePath, javac, annotations), JavaPrimitiveType { override val type: PrimitiveType? get() = if (tree.primitiveTypeKind == TypeKind.VOID) { @@ -79,22 +88,24 @@ class TreeBasedPrimitiveType( class TreeBasedArrayType( tree: JCTree.JCArrayTypeTree, treePath: TreePath, - javac: JavacWrapper -) : TreeBasedType(tree, treePath, javac), JavaArrayType { + javac: JavacWrapper, + annotations: Collection +) : TreeBasedType(tree, treePath, javac, annotations), JavaArrayType { override val componentType: JavaType - get() = create(tree.elemtype, treePath, javac) + get() = create(tree.elemtype, treePath, javac, annotations) } class TreeBasedWildcardType( tree: JCTree.JCWildcard, treePath: TreePath, - javac: JavacWrapper -) : TreeBasedType(tree, treePath, javac), JavaWildcardType { + javac: JavacWrapper, + annotations: Collection +) : TreeBasedType(tree, treePath, javac, annotations), JavaWildcardType { override val bound: JavaType? - get() = tree.bound?.let { create(it, treePath, javac) } + get() = tree.bound?.let { create(it, treePath, javac, annotations) } override val isExtends: Boolean get() = tree.kind.kind == BoundKind.EXTENDS @@ -104,18 +115,47 @@ class TreeBasedWildcardType( sealed class TreeBasedClassifierType( tree: T, treePath: TreePath, - javac: JavacWrapper -) : TreeBasedType(tree, treePath, javac), JavaClassifierType { + javac: JavacWrapper, + annotations: Collection +) : TreeBasedType(tree, treePath, javac, annotations), JavaClassifierType { override val classifier: JavaClassifier? get() = javac.resolve(treePath) override val classifierQualifiedName: String - get() = (classifier as? JavaClass)?.fqName?.asString() ?: treePath.leaf.toString() + get() = (classifier as? JavaClass)?.fqName?.asString() ?: treePath.leaf.toString().substringBefore("<") override val presentableText: String get() = classifierQualifiedName + override val typeArguments: List + get() { + var tree: JCTree = tree + if (tree is JCTree.JCTypeApply) { + tree = tree.clazz + } + if (tree is JCTree.JCFieldAccess) { + val enclosingType = TreeBasedType.create(tree.selected, treePath, javac, annotations) + return (enclosingType as? JavaClassifierType)?.typeArguments ?: emptyList() + } + else { + val classifier = classifier as? JavaClass ?: return emptyList() + if (classifier is MockKotlinClassifier || classifier.isStatic) return emptyList() + + return arrayListOf().apply { + var outer = classifier.outerClass + var staticType = false + while (outer != null && !staticType) { + if (outer.isStatic) { + staticType = true + } + add(outer) + outer = outer.outerClass + } + }.flatMap { it.typeParameters.map(::TreeBasedTypeParameterType) } + } + } + private val typeParameter: JCTree.JCTypeParameter? get() = treePath.flatMap { when (it) { @@ -128,15 +168,36 @@ sealed class TreeBasedClassifierType( } -class TreeBasedNonGenericClassifierType( - tree: JCTree.JCExpression, - treePath: TreePath, - javac: JavacWrapper -) : TreeBasedClassifierType(tree, treePath, javac) { +class TreeBasedTypeParameterType(override val classifier: JavaTypeParameter) : JavaClassifierType { override val typeArguments: List get() = emptyList() + override val isRaw: Boolean + get() = false + + override val annotations: Collection + get() = classifier.annotations.filterTypeAnnotations() + + override val classifierQualifiedName: String + get() = classifier.name.asString() + + override val presentableText: String + get() = classifierQualifiedName + + override fun findAnnotation(fqName: FqName) = annotations.find { it.classId?.asSingleFqName() == fqName } + + override val isDeprecatedInJavaDoc: Boolean + get() = false +} + +class TreeBasedNonGenericClassifierType( + tree: JCTree.JCExpression, + treePath: TreePath, + javac: JavacWrapper, + annotations: Collection +) : TreeBasedClassifierType(tree, treePath, javac, annotations) { + override val isRaw: Boolean get() = (classifier as? MockKotlinClassifier)?.hasTypeParameters ?: (classifier as? JavaClass)?.typeParameters?.isNotEmpty() @@ -147,13 +208,39 @@ class TreeBasedNonGenericClassifierType( class TreeBasedGenericClassifierType( tree: JCTree.JCTypeApply, treePath: TreePath, - javac: JavacWrapper -) : TreeBasedClassifierType(tree, treePath, javac) { + javac: JavacWrapper, + annotations: Collection +) : TreeBasedClassifierType(tree, treePath, javac, annotations) { + + override val classifier: JavaClassifier? + get() { + val newTree = tree.clazz + return if (newTree is JCTree.JCAnnotatedType) { + javac.resolve(javac.getTreePath(newTree.underlyingType, treePath.compilationUnit)) + } + else super.classifier + } + + override val annotations: Collection + get() { + val newTree = tree.clazz + return (newTree as? JCTree.JCAnnotatedType)?.annotations?.map { TreeBasedAnnotation(it, javac.getTreePath(it, treePath.compilationUnit), javac) } + ?.toMutableList() + ?.apply { addAll(super.annotations) } + ?: super.annotations + } override val typeArguments: List - get() = tree.arguments.map { create(it, treePath, javac) } + get() = tree.arguments.map { create(it, treePath, javac, emptyList()) } + .toMutableList() + .apply { addAll(super.typeArguments) } override val isRaw: Boolean - get() = false + get() = classifier.let { + when (it) { + is MockKotlinClassifier -> tree.arguments.size != it.typeParametersNumber + else -> tree.arguments.size != (classifier as? JavaClass)?.typeParameters?.size + } + } } \ No newline at end of file diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/utils.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/utils.kt index 54378e0b5c9..b61b4a30665 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/utils.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/wrappers/trees/utils.kt @@ -19,9 +19,15 @@ package org.jetbrains.kotlin.javac.wrappers.trees import com.sun.tools.javac.tree.JCTree import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedArrayAnnotationArgument +import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedField +import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedReferenceAnnotationArgument import org.jetbrains.kotlin.load.java.JavaVisibilities +import org.jetbrains.kotlin.load.java.structure.JavaAnnotation import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name import javax.lang.model.element.Modifier internal val JCTree.JCModifiers.isAbstract: Boolean @@ -58,4 +64,38 @@ internal fun JCTree.annotations(): Collection = when (this) } ?: emptyList() fun JavaClass.computeClassId(): ClassId? = - outerClass?.computeClassId()?.createNestedClassId(name) ?: fqName?.let { ClassId.topLevel(it) } \ No newline at end of file + outerClass?.computeClassId()?.createNestedClassId(name) ?: fqName?.let { ClassId.topLevel(it) } + +fun Collection.filterTypeAnnotations(): Collection { + val filteredAnnotations = arrayListOf() + for (annotation in this) { + val annotationClass = annotation.resolve() + val targetAnnotation = annotationClass?.annotations?.find { it.classId == ClassId(FqName("java.lang.annotation"), Name.identifier("Target")) } ?: continue + val elementTypeArg = targetAnnotation.arguments.firstOrNull() ?: continue + + when (elementTypeArg) { + is SymbolBasedArrayAnnotationArgument -> { + elementTypeArg.args.find { (it as? SymbolBasedReferenceAnnotationArgument)?.element?.simpleName?.contentEquals("TYPE_USE") ?: false } + ?.let { filteredAnnotations.add(annotation) } + } + is SymbolBasedReferenceAnnotationArgument -> { + elementTypeArg.element.simpleName.takeIf { it.contentEquals("TYPE_USE") } + ?.let { filteredAnnotations.add(annotation) } + } + is TreeBasedArrayAnnotationArgument -> { + elementTypeArg.args.find { + val field = (it as? TreeBasedReferenceAnnotationArgument)?.resolve() as? SymbolBasedField + field?.element?.simpleName?.contentEquals("TYPE_USE") ?: false + }?.let { filteredAnnotations.add(annotation) } + } + is TreeBasedReferenceAnnotationArgument -> { + (elementTypeArg.resolve() as? SymbolBasedField)?.let { field -> + field.element.simpleName.takeIf { it.contentEquals("TYPE_USE") } + ?.let { filteredAnnotations.add(annotation) } + } + } + } + } + + return filteredAnnotations +} \ No newline at end of file diff --git a/compiler/testData/compileKotlinAgainstJava/AbstractEnum.txt b/compiler/testData/compileKotlinAgainstJava/AbstractEnum.txt index 29039547669..cfecaae18a2 100644 --- a/compiler/testData/compileKotlinAgainstJava/AbstractEnum.txt +++ b/compiler/testData/compileKotlinAgainstJava/AbstractEnum.txt @@ -16,7 +16,5 @@ public abstract enum class AbstractEnum : kotlin.Enum { // Static members public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.AbstractEnum - public open fun valueOf(/*0*/ kotlin.String!): test.AbstractEnum! - public open fun values(): kotlin.Array<(out) test.AbstractEnum!>! public final /*synthesized*/ fun values(): kotlin.Array } diff --git a/compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.txt b/compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.txt index eaec38e02ca..5fbd391dbb4 100644 --- a/compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.txt +++ b/compiler/testData/compileKotlinAgainstJava/ClassWithNestedEnum.txt @@ -22,8 +22,6 @@ public open class ClassWithNestedEnum { // Static members public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.ClassWithNestedEnum.NestedEnum - public open fun valueOf(/*0*/ kotlin.String!): test.ClassWithNestedEnum.NestedEnum! - public open fun values(): kotlin.Array<(out) test.ClassWithNestedEnum.NestedEnum!>! public final /*synthesized*/ fun values(): kotlin.Array } } diff --git a/compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.txt b/compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.txt index 842dc4a9ced..b138c86d607 100644 --- a/compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.txt +++ b/compiler/testData/compileKotlinAgainstJava/EnclosingClassInner.txt @@ -25,8 +25,6 @@ public/*package*/ interface Interface { // Static members public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.Interface.Kind - public open fun valueOf(/*0*/ kotlin.String!): test.Interface.Kind! - public open fun values(): kotlin.Array<(out) test.Interface.Kind!>! public final /*synthesized*/ fun values(): kotlin.Array } } diff --git a/compiler/testData/compileKotlinAgainstJava/Enum.txt b/compiler/testData/compileKotlinAgainstJava/Enum.txt index 3a14a997630..690570b151c 100644 --- a/compiler/testData/compileKotlinAgainstJava/Enum.txt +++ b/compiler/testData/compileKotlinAgainstJava/Enum.txt @@ -21,7 +21,5 @@ public final enum class Enum : kotlin.Enum { // Static members public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.Enum - public open fun valueOf(/*0*/ kotlin.String!): test.Enum! - public open fun values(): kotlin.Array<(out) test.Enum!>! public final /*synthesized*/ fun values(): kotlin.Array } diff --git a/compiler/testData/compileKotlinAgainstJava/EnumName.txt b/compiler/testData/compileKotlinAgainstJava/EnumName.txt index 026a18a70c2..e4ec62c11dd 100644 --- a/compiler/testData/compileKotlinAgainstJava/EnumName.txt +++ b/compiler/testData/compileKotlinAgainstJava/EnumName.txt @@ -17,7 +17,5 @@ public final enum class EnumName : kotlin.Enum { // Static members public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.EnumName - public open fun valueOf(/*0*/ kotlin.String!): test.EnumName! - public open fun values(): kotlin.Array<(out) test.EnumName!>! public final /*synthesized*/ fun values(): kotlin.Array } diff --git a/compiler/testData/compileKotlinAgainstJava/EnumValues.java b/compiler/testData/compileKotlinAgainstJava/EnumValues.java new file mode 100644 index 00000000000..2e5b402fae4 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/EnumValues.java @@ -0,0 +1,18 @@ +package test; + +public enum EnumValues { + OK(0), + COMPILATION_ERROR(1), + INTERNAL_ERROR(2), + SCRIPT_EXECUTION_ERROR(3); + + private final int code; + + EnumValues(int code) { + this.code = code; + } + + public int getCode() { + return code; + } +} diff --git a/compiler/testData/compileKotlinAgainstJava/EnumValues.kt b/compiler/testData/compileKotlinAgainstJava/EnumValues.kt new file mode 100644 index 00000000000..31312a86eae --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/EnumValues.kt @@ -0,0 +1,5 @@ +package test + +import java.util.Locale + +fun findCode(code: Int) = Locale.Category.values() diff --git a/compiler/testData/compileKotlinAgainstJava/EnumValues.txt b/compiler/testData/compileKotlinAgainstJava/EnumValues.txt new file mode 100644 index 00000000000..6c596a81241 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/EnumValues.txt @@ -0,0 +1,27 @@ +package test + +public fun findCode(/*0*/ kotlin.Int): kotlin.Array + +public final enum class EnumValues : kotlin.Enum { + enum entry OK + + enum entry COMPILATION_ERROR + + enum entry INTERNAL_ERROR + + enum entry SCRIPT_EXECUTION_ERROR + + private constructor EnumValues(/*0*/ kotlin.Int) + private final val code: kotlin.Int + public final /*fake_override*/ val name: kotlin.String + public final /*fake_override*/ val ordinal: kotlin.Int + protected final /*fake_override*/ fun clone(): kotlin.Any + public final /*fake_override*/ fun compareTo(/*0*/ test.EnumValues!): kotlin.Int + protected/*protected and package*/ final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun finalize(): kotlin.Unit + public open fun getCode(): kotlin.Int + public final /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun getDeclaringClass(): java.lang.Class! + + // Static members + public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.EnumValues + public final /*synthesized*/ fun values(): kotlin.Array +} diff --git a/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.java b/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.java new file mode 100644 index 00000000000..11a0884b350 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.java @@ -0,0 +1,10 @@ +package test; + +public abstract class InnerWithGenericOuter { + + public class Module { + } + + protected abstract void test(Module module); + +} diff --git a/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.kt b/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.kt new file mode 100644 index 00000000000..fef88c181b7 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.kt @@ -0,0 +1,7 @@ +package test + +class BasicTest : InnerWithGenericOuter() { + + override fun test(module: Module) {} + +} diff --git a/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.txt b/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.txt new file mode 100644 index 00000000000..f031a211fe7 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.txt @@ -0,0 +1,15 @@ +package test + +public final class BasicTest : test.InnerWithGenericOuter { + public constructor BasicTest() + protected open fun test(/*0*/ test.InnerWithGenericOuter.Module): kotlin.Unit +} + +public abstract class InnerWithGenericOuter { + public constructor InnerWithGenericOuter() + protected/*protected and package*/ abstract fun test(/*0*/ test.InnerWithGenericOuter.Module!): kotlin.Unit + + public open inner class Module /*captured type parameters: /*0*/ T : kotlin.Any!*/ { + public constructor Module() + } +} diff --git a/compiler/testData/compileKotlinAgainstJava/JavaLangClass.java b/compiler/testData/compileKotlinAgainstJava/JavaLangClass.java new file mode 100644 index 00000000000..d585c56bbd8 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/JavaLangClass.java @@ -0,0 +1,7 @@ +package test; + +public class JavaLangClass { + + public static void func(Class aClass) {} + +} diff --git a/compiler/testData/compileKotlinAgainstJava/JavaLangClass.kt b/compiler/testData/compileKotlinAgainstJava/JavaLangClass.kt new file mode 100644 index 00000000000..113307c1568 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/JavaLangClass.kt @@ -0,0 +1,3 @@ +package test + +fun doNothing() = JavaLangClass.func(String::class.java) diff --git a/compiler/testData/compileKotlinAgainstJava/JavaLangClass.txt b/compiler/testData/compileKotlinAgainstJava/JavaLangClass.txt new file mode 100644 index 00000000000..430050cfe32 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstJava/JavaLangClass.txt @@ -0,0 +1,10 @@ +package test + +public fun doNothing(): kotlin.Unit + +public open class JavaLangClass { + public constructor JavaLangClass() + + // Static members + public open fun func(/*0*/ java.lang.Class!): kotlin.Unit +} diff --git a/compiler/testData/compileKotlinAgainstJava/ReturnEnum.txt b/compiler/testData/compileKotlinAgainstJava/ReturnEnum.txt index 3f682dd3b4d..27dcddd1d7e 100644 --- a/compiler/testData/compileKotlinAgainstJava/ReturnEnum.txt +++ b/compiler/testData/compileKotlinAgainstJava/ReturnEnum.txt @@ -19,8 +19,6 @@ public/*package*/ final enum class Kind : kotlin.Enum { // Static members public final /*synthesized*/ fun valueOf(/*0*/ kotlin.String): test.Kind - public open fun valueOf(/*0*/ kotlin.String!): test.Kind! - public open fun values(): kotlin.Array<(out) test.Kind!>! public final /*synthesized*/ fun values(): kotlin.Array } diff --git a/compiler/testData/compileKotlinAgainstJava/ReturnType.java b/compiler/testData/compileKotlinAgainstJava/ReturnType.java index bb6c6f31682..e164de66c16 100644 --- a/compiler/testData/compileKotlinAgainstJava/ReturnType.java +++ b/compiler/testData/compileKotlinAgainstJava/ReturnType.java @@ -4,4 +4,6 @@ public class ReturnType { public static javax.lang.model.element.Element getElement() { return null; } + public static java.lang.Class getJavaLangClass() { return null; } + } diff --git a/compiler/testData/compileKotlinAgainstJava/ReturnType.kt b/compiler/testData/compileKotlinAgainstJava/ReturnType.kt index 60dba86708d..5a99d2b64b9 100644 --- a/compiler/testData/compileKotlinAgainstJava/ReturnType.kt +++ b/compiler/testData/compileKotlinAgainstJava/ReturnType.kt @@ -1,3 +1,5 @@ package test fun getElement() = ReturnType.getElement() + +fun getJavaLangClass() = ReturnType.getJavaLangClass() diff --git a/compiler/testData/compileKotlinAgainstJava/ReturnType.txt b/compiler/testData/compileKotlinAgainstJava/ReturnType.txt index a529c5f2d44..0f3bfa8673d 100644 --- a/compiler/testData/compileKotlinAgainstJava/ReturnType.txt +++ b/compiler/testData/compileKotlinAgainstJava/ReturnType.txt @@ -1,10 +1,12 @@ package test public fun getElement(): javax.lang.model.element.Element! +public fun getJavaLangClass(): java.lang.Class! public open class ReturnType { public constructor ReturnType() // Static members public open fun getElement(): javax.lang.model.element.Element! + public open fun getJavaLangClass(): java.lang.Class! } diff --git a/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.java b/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.java deleted file mode 100644 index 4b26622c572..00000000000 --- a/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.java +++ /dev/null @@ -1,16 +0,0 @@ -package test; - -public class UseKotlinInner extends KotlinClass { - - KotlinInner getKotlinInner() { return null; } - - JavaInner getJavaInner() { return null; } - - KotlinInner3 getKotlinInner3() { return null; } -} - -class JavaClass2 { - - static class JavaInner {} - -} diff --git a/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.kt b/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.kt deleted file mode 100644 index 6e4ed5805ca..00000000000 --- a/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.kt +++ /dev/null @@ -1,19 +0,0 @@ -package test - -private open class KotlinClass : KotlinInterface.KotlinInner2() { - - inner class KotlinInner - -} - -private interface KotlinInterface { - open class KotlinInner2 : JavaClass2() { - class KotlinInner3 - } -} - -private fun getKotlinInner() = UseKotlinInner().kotlinInner - -private fun getJavaInner() = UseKotlinInner().javaInner - -private fun getKotlinInner3() = UseKotlinInner().kotlinInner3 diff --git a/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.txt b/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.txt deleted file mode 100644 index 64dc12aada6..00000000000 --- a/compiler/testData/compileKotlinAgainstJava/UseKotlinInner.txt +++ /dev/null @@ -1,39 +0,0 @@ -package test - -private fun getJavaInner(): test.JavaClass2.JavaInner! -private fun getKotlinInner(): test.KotlinClass.KotlinInner! -private fun getKotlinInner3(): test.KotlinInterface.KotlinInner2.KotlinInner3! - -public/*package*/ open class JavaClass2 { - public/*package*/ constructor JavaClass2() - - public/*package*/ open class JavaInner { - public/*package*/ constructor JavaInner() - } -} - -private open class KotlinClass : test.KotlinInterface.KotlinInner2 { - public constructor KotlinClass() - - public final inner class KotlinInner { - public constructor KotlinInner() - } -} - -private interface KotlinInterface { - - public open class KotlinInner2 : test.JavaClass2 { - public constructor KotlinInner2() - - public final class KotlinInner3 { - public constructor KotlinInner3() - } - } -} - -public open class UseKotlinInner : test.KotlinClass { - public constructor UseKotlinInner() - public/*package*/ open fun getJavaInner(): test.JavaClass2.JavaInner! - public/*package*/ open fun getKotlinInner(): test.KotlinClass.KotlinInner! - public/*package*/ open fun getKotlinInner3(): test.KotlinInterface.KotlinInner2.KotlinInner3! -} diff --git a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.javac.txt b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.javac.txt new file mode 100644 index 00000000000..5a20e50a7d1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.javac.txt @@ -0,0 +1,15 @@ +package + +public interface MyTrait : java.lang.Object { + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ fun finalize(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun getClass(): java.lang.Class<*>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final override /*1*/ /*fake_override*/ fun notify(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun notifyAll(): kotlin.Unit + public abstract override /*1*/ fun toString(): kotlin.String + public abstract override /*1*/ fun wait(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun wait(/*0*/ p0: kotlin.Long): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun wait(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt index 8eb44a1b6f2..339fcc5587a 100644 --- a/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt +++ b/compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE interface MyTrait: Object { override fun toString(): String public override fun finalize() diff --git a/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.javac.txt b/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.javac.txt new file mode 100644 index 00000000000..b89187339bc --- /dev/null +++ b/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.javac.txt @@ -0,0 +1,67 @@ +package + +public open class Bar { + public constructor Bar() + public final val v: kotlin.Int = 1 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public final fun v(): kotlin.Int +} + +public final class Barr : Bar { + public constructor Barr() + public final override /*1*/ /*fake_override*/ val v: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public final override /*1*/ /*fake_override*/ fun v(): kotlin.Int +} + +public final class Foo1 : java.util.ArrayList { + public constructor Foo1() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.Int! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.Int + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt b/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt index 638313bc78d..6331a7778ed 100644 --- a/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt +++ b/compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt @@ -1,4 +1,4 @@ - +// JAVAC_EXPECTED_FILE class Foo1() : java.util.ArrayList() open class Bar() { diff --git a/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt b/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt index 3292157f7a0..3c50e6cf83b 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt +++ b/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt @@ -4,11 +4,11 @@ import java.lang.annotation.*; public class DocumentedAnnotations { - @Documented public @interface DocAnn; + @Documented public @interface DocAnn {}; - public @interface NotDocAnn; + public @interface NotDocAnn {}; - @Documented @Retention(RetentionPolicy.RUNTIME) public @interface RunDocAnn; + @Documented @Retention(RetentionPolicy.RUNTIME) public @interface RunDocAnn {}; } // FILE: DocumentedAnnotations.kt diff --git a/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt b/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt index 428d927f687..1cc92a66444 100644 --- a/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt +++ b/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt @@ -1,7 +1,7 @@ // !CHECK_TYPE // FILE: test/A.java -package test +package test; import java.util.Arrays; diff --git a/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.txt b/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.txt index 1201fb49fd9..571a4bd80de 100644 --- a/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.txt +++ b/compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.txt @@ -1,3 +1,16 @@ package public fun foo(/*0*/ args: kotlin.Array): kotlin.Unit + +package test { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun main(/*0*/ args: kotlin.Array<(out) kotlin.String!>!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/callableReference/sam.txt b/compiler/testData/diagnostics/tests/callableReference/sam.txt index 893d509e159..01c40b03a16 100644 --- a/compiler/testData/diagnostics/tests/callableReference/sam.txt +++ b/compiler/testData/diagnostics/tests/callableReference/sam.txt @@ -16,3 +16,13 @@ public fun g5(): kotlin.reflect.KClass> public fun g6(): kotlin.reflect.KFunction1<@kotlin.ParameterName(name = "t") kotlin.String!, kotlin.Unit> public fun g7(): kotlin.reflect.KClass> public fun g8(): kotlin.reflect.KFunction1<@kotlin.ParameterName(name = "t") kotlin.String!, kotlin.Unit> + +package test { + + public interface GenericSam { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract operator fun invoke(/*0*/ t: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt b/compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt index 5dd66687fbf..47dc1846d25 100644 --- a/compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt +++ b/compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt @@ -1,7 +1,7 @@ // FILE: JavaClass.java -import org.jetbrains.annotations.Nullable -import org.jetbrains.annotations.NotNull +import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.NotNull; public class JavaClass { static Integer foo() { @@ -35,4 +35,4 @@ fun test(x1: T, x2: T?, y1: S, y2: S?) { val f3 = JavaClass.fooNN() f3 is Int? -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.javac.txt b/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.javac.txt new file mode 100644 index 00000000000..6b0fdd9dc26 --- /dev/null +++ b/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.javac.txt @@ -0,0 +1,65 @@ +package + +public fun bar(): kotlin.Unit +public fun tryCatch(): kotlin.Unit +public inline fun tryCatch(/*0*/ lazy: () -> R, /*1*/ failure: (E) -> R): R + +public final class XException : kotlin.Throwable { + public constructor XException(/*0*/ p: T) + public open override /*1*/ /*fake_override*/ val cause: kotlin.Throwable? + public open override /*1*/ /*fake_override*/ val message: kotlin.String? + public final val p: T + public final override /*1*/ /*fake_override*/ fun addSuppressed(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun fillInStackTrace(): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun getLocalizedMessage(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public final override /*1*/ /*fake_override*/ fun getSuppressed(): kotlin.Array<(out) kotlin.Throwable!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun initCause(/*0*/ p0: kotlin.Throwable!): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun printStackTrace(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setStackTrace(/*0*/ p0: kotlin.Array<(out) java.lang.StackTraceElement!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class YException : java.lang.RuntimeException { + public constructor YException(/*0*/ p: T) + public open override /*1*/ /*fake_override*/ val cause: kotlin.Throwable? + public open override /*1*/ /*fake_override*/ val message: kotlin.String? + public final val p: T + public final override /*1*/ /*fake_override*/ fun addSuppressed(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun fillInStackTrace(): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun getLocalizedMessage(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public final override /*1*/ /*fake_override*/ fun getSuppressed(): kotlin.Array<(out) kotlin.Throwable!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun initCause(/*0*/ p0: kotlin.Throwable!): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun printStackTrace(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setStackTrace(/*0*/ p0: kotlin.Array<(out) java.lang.StackTraceElement!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class ZException : kotlin.Exception /* = java.lang.Exception */ { + public constructor ZException(/*0*/ p: T) + public open override /*1*/ /*fake_override*/ val cause: kotlin.Throwable? + public open override /*1*/ /*fake_override*/ val message: kotlin.String? + public final val p: T + public final override /*1*/ /*fake_override*/ fun addSuppressed(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun fillInStackTrace(): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun getLocalizedMessage(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public final override /*1*/ /*fake_override*/ fun getSuppressed(): kotlin.Array<(out) kotlin.Throwable!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun initCause(/*0*/ p0: kotlin.Throwable!): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun printStackTrace(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setStackTrace(/*0*/ p0: kotlin.Array<(out) java.lang.StackTraceElement!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt b/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt index 31f9d012434..74564111367 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // See KT-9816, KT-9742 // Not allowed in Java diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.javac.txt b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.javac.txt new file mode 100644 index 00000000000..c6a9cb28d86 --- /dev/null +++ b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.javac.txt @@ -0,0 +1,24 @@ +package + +public final class TestIface : java.lang.Runnable { + public constructor TestIface(/*0*/ r: java.lang.Runnable) + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*delegation*/ fun run(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class TestObject : java.lang.Object { + public constructor TestObject(/*0*/ o: java.lang.Object) + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun finalize(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun getClass(): java.lang.Class<*>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final override /*1*/ /*fake_override*/ fun notify(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun notifyAll(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public final override /*1*/ /*fake_override*/ fun wait(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun wait(/*0*/ p0: kotlin.Long): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun wait(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt index cc41288b3b0..38d91fa982d 100644 --- a/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt +++ b/compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE class TestIface(r : Runnable) : Runnable by r {} class TestObject(o : Object) : Object by o {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt index 07a720ac0dd..2a98cec122b 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt @@ -3,7 +3,7 @@ // FILE: A.java public class A { - public static int a = 1 + public static int a = 1; public static void foo() {} public static void baz(String s) {} } diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt index a1adb7e0513..ab9eaf23907 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt @@ -18,3 +18,17 @@ public open class K : foo.A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + +package foo { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public/*package*/ open fun bar(/*0*/ s: kotlin.Double): kotlin.Unit + private open fun foo(/*0*/ s: kotlin.Int): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.txt b/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.txt index bd5c3ffa11c..6d4346be57e 100644 --- a/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.txt +++ b/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.txt @@ -9,3 +9,28 @@ public final class K : p.J.C { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String public final fun dynamic.test(): kotlin.Unit } + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class C { + public constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + private open fun sam(/*0*/ sam: p.J.Sam!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Sam { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract fun sam(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/diagnostics/tests/exposed/inaccessibleType.txt b/compiler/testData/diagnostics/tests/exposed/inaccessibleType.txt index be547868ba7..c573f20244b 100644 --- a/compiler/testData/diagnostics/tests/exposed/inaccessibleType.txt +++ b/compiler/testData/diagnostics/tests/exposed/inaccessibleType.txt @@ -1,5 +1,39 @@ package +package j { + + public interface Base { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Derived1 : j.Impl { + public constructor Derived1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Derived2 : j.Impl { + public constructor Derived2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ abstract class Impl : j.Base { + public/*package*/ constructor Impl() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + package k { public val d1: j.Derived1 public val d2: j.Derived2 diff --git a/compiler/testData/diagnostics/tests/exposed/packagePrivate.javac.txt b/compiler/testData/diagnostics/tests/exposed/packagePrivate.javac.txt new file mode 100644 index 00000000000..06f34e55ba4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/exposed/packagePrivate.javac.txt @@ -0,0 +1,43 @@ +package + +package other { + + public final class Your { + public constructor Your() + internal final fun bar(): test.Internal! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package test { + + public final class His { + public constructor His() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + internal final fun internal(): test.Internal! + private final fun private(): test.Internal! + protected final fun protected(): test.Internal! + public final fun public(): test.Internal! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open class Internal { + public/*package*/ constructor Internal() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class My { + public constructor My() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun foo(): test.Internal! + } +} diff --git a/compiler/testData/diagnostics/tests/exposed/packagePrivate.kt b/compiler/testData/diagnostics/tests/exposed/packagePrivate.kt index ba18543da2d..7f4706dcda3 100644 --- a/compiler/testData/diagnostics/tests/exposed/packagePrivate.kt +++ b/compiler/testData/diagnostics/tests/exposed/packagePrivate.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: test/My.java package test; diff --git a/compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt b/compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt index ca980a931d7..11a06ccb799 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt @@ -1,7 +1,7 @@ // !CHECK_TYPE // FILE: Predicate.java -import org.jetbrains.annotations.NotNull +import org.jetbrains.annotations.NotNull; public interface Predicate { // Same effect with @Nullable here @@ -13,4 +13,4 @@ fun main(args: Array) { process(Predicate { x -> x checkType { _() } true }) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.javac.txt b/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.javac.txt new file mode 100644 index 00000000000..2ff8ddb0861 --- /dev/null +++ b/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.javac.txt @@ -0,0 +1,13 @@ +package + +package test { + public fun foo(/*0*/ u: test.Usage): kotlin.Unit + + public open class Usage { + public constructor Usage() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open fun foo(/*0*/ c: kotlin.collections.(Mutable)Collection<*>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt b/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt index 4716ee25328..f4fee390b7f 100644 --- a/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt +++ b/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: java/util/Collection.java package java.util; diff --git a/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.txt b/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.txt index 2ff8ddb0861..72295e959e8 100644 --- a/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.txt +++ b/compiler/testData/diagnostics/tests/generics/PseudoRawTypes.txt @@ -1,5 +1,73 @@ package +package java { + + package java.awt { + + package java.awt.event { + } + } + + package java.beans { + + package java.beans.beancontext { + } + } + + package java.io { + } + + package java.lang { + + package java.lang.annotation { + } + + package java.lang.reflect { + } + } + + package java.net { + } + + package java.nio { + + package java.nio.charset { + } + } + + package java.rmi { + } + + package java.security { + } + + package java.sql { + } + + package java.util { + + public open class Collection { + public constructor Collection() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + package java.util.concurrent { + + package java.util.concurrent.atomic { + } + + package java.util.concurrent.locks { + } + } + + package java.util.regex { + } + } +} + package test { public fun foo(/*0*/ u: test.Usage): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.javac.txt b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.javac.txt new file mode 100644 index 00000000000..2299fd6a00d --- /dev/null +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.javac.txt @@ -0,0 +1,34 @@ +package + +public fun commonSupertype(/*0*/ x: E, /*1*/ y: E): E +public fun foo(): kotlin.Unit + +public final class A : java.util.AbstractCollection { + public constructor A() + public open override /*1*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ fun iterator(): A.MyIt + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final inner class MyIt /*captured type parameters: /*0*/ T*/ : kotlin.collections.MutableIterator { + public constructor MyIt() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ fun hasNext(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun next(): T + public open override /*1*/ fun remove(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt index fb2fb4b83ef..1c981b2b132 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt @@ -1,5 +1,6 @@ // !CHECK_TYPE // !DIAGNOSTICS: -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_VARIABLE +// JAVAC_EXPECTED_FILE import java.util.* class A : AbstractCollection() { diff --git a/compiler/testData/diagnostics/tests/generics/kt9985.kt b/compiler/testData/diagnostics/tests/generics/kt9985.kt index f648b646555..73f71d9693d 100644 --- a/compiler/testData/diagnostics/tests/generics/kt9985.kt +++ b/compiler/testData/diagnostics/tests/generics/kt9985.kt @@ -5,7 +5,7 @@ public class B { public String gav() { - return "" + return ""; } public static B create() { diff --git a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt index 5c6ca5fc41d..f66b9bb2389 100644 --- a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt +++ b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt @@ -1,3 +1,4 @@ +// JAVAC_SKIP // FILE: JavaClass.java public class JavaClass { public void foo(? x) {} diff --git a/compiler/testData/diagnostics/tests/inference/immutableArrayList.txt b/compiler/testData/diagnostics/tests/inference/immutableArrayList.txt index b58c65babcf..10f0373b13d 100644 --- a/compiler/testData/diagnostics/tests/inference/immutableArrayList.txt +++ b/compiler/testData/diagnostics/tests/inference/immutableArrayList.txt @@ -7,3 +7,24 @@ public final class Foo : p.J.Sub { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package p { + + public interface J { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public interface Sub : p.J.Super { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Super { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.javac.txt b/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.javac.txt new file mode 100644 index 00000000000..a0857700815 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.javac.txt @@ -0,0 +1,96 @@ +package + +public abstract class AL : java.util.ArrayList { + public constructor AL() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: p.P): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: p.P): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: p.P): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): p.P! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): p.P + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: p.P): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: p.P): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: p.P): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): p.P + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: p.P): p.P + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} + +public abstract class K : p.C { + public constructor K() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun foo(/*0*/ p: p.A): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +package p { + + public interface A { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun foo(/*0*/ p: p.A): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class B : p.A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open override /*1*/ fun foo(/*0*/ p: p.A): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class C : p.B, p.A { + public constructor C() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun foo(/*0*/ p: p.A): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface G { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class P { + public constructor P() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt b/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt index 4c9969aaa63..08fb60a0a99 100644 --- a/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt +++ b/compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: p/G.java package p; diff --git a/compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.txt b/compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.txt index 51db85258e4..e7012468a66 100644 --- a/compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.txt +++ b/compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.txt @@ -7,3 +7,29 @@ public abstract class K : p.C { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package p { + + public interface A { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun foo(/*0*/ p: TA!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class B : p.A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open override /*1*/ fun foo(/*0*/ p: TB!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class C : p.B, p.A { + public constructor C() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun foo(/*0*/ p: TA!): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/Simple.txt b/compiler/testData/diagnostics/tests/j+k/Simple.txt index 932d4980b1c..60db73c62b1 100644 --- a/compiler/testData/diagnostics/tests/j+k/Simple.txt +++ b/compiler/testData/diagnostics/tests/j+k/Simple.txt @@ -1,3 +1,14 @@ package public fun foo(/*0*/ a: aa.A): kotlin.Unit + +package aa { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun f(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.javac.txt b/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.javac.txt new file mode 100644 index 00000000000..807261e07e3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.javac.txt @@ -0,0 +1,11 @@ +package + +public fun main(): kotlin.Unit + +@missing.Ann /* annotation class not found */ public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @missing.Ann /* annotation class not found */ public open fun foo(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt b/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt index 90f3fc6ea16..5b02912d9bc 100644 --- a/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt +++ b/compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: A.java @missing.Ann(x = "") public class A { diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.javac.txt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.javac.txt new file mode 100644 index 00000000000..e43e32a9e4a --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.javac.txt @@ -0,0 +1,124 @@ +package + +public fun foo(/*0*/ a: A, /*1*/ b: B, /*2*/ ic: IC, /*3*/ ka: KA, /*4*/ kb: KB, /*5*/ al: java.util.ArrayList): kotlin.Unit + +public abstract class A : kotlin.collections.MutableCollection { + public constructor A() + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public abstract class B : kotlin.collections.MutableCollection { + public constructor B() + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ fun contains(/*0*/ x: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public interface IC : kotlin.collections.MutableCollection { + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ fun contains(/*0*/ x: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public abstract class KA : java.util.AbstractList { + public constructor KA() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ fun contains(/*0*/ x: T): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): T! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T!): T! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public abstract class KB : java.util.AbstractList, IC { + public constructor KB() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*2*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*2*/ fun contains(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt index f6a6da135d8..10dca828f47 100644 --- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -PARAMETER_NAME_CHANGED_ON_OVERRIDE +// JAVAC_EXPECTED_FILE // FILE: A.java abstract public class A implements java.util.Collection { @@ -12,7 +13,7 @@ abstract public class B implements java.util.Collection { } // FILE: IC.java -public interface IC implements java.util.Collection { +public interface IC extends java.util.Collection { public boolean contains(Object x); } diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.javac.txt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.javac.txt new file mode 100644 index 00000000000..aa133d04069 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.javac.txt @@ -0,0 +1,124 @@ +package + +public fun foo(/*0*/ a: A, /*1*/ b: B, /*2*/ ic: IC, /*3*/ ka: KA, /*4*/ kb: KB, /*5*/ al: java.util.ArrayList, /*6*/ cs: kotlin.collections.Collection, /*7*/ ca: kotlin.collections.Collection): kotlin.Unit + +public abstract class A : kotlin.collections.MutableCollection { + public constructor A() + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public abstract class B : kotlin.collections.MutableCollection { + public constructor B() + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public interface IC : kotlin.collections.MutableCollection { + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public abstract class KA : java.util.AbstractList { + public constructor KA() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ fun containsAll(/*0*/ x: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): T! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T!): T! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public abstract class KB : java.util.AbstractList, IC { + public constructor KB() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*2*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*2*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt index b3da9f3a88d..b983433f2fd 100644 --- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -PARAMETER_NAME_CHANGED_ON_OVERRIDE +// JAVAC_EXPECTED_FILE // FILE: A.java import java.util.*; @@ -16,7 +17,7 @@ abstract public class B implements java.util.Collection { // FILE: IC.java import java.util.*; -public interface IC implements java.util.Collection { +public interface IC extends java.util.Collection { public boolean containsAll(Collection x); } diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.javac.txt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.javac.txt new file mode 100644 index 00000000000..9fcbd7169b4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.javac.txt @@ -0,0 +1,28 @@ +package + +public fun foo(/*0*/ m: MyMap): kotlin.Unit + +public abstract class MyMap : java.util.AbstractMap { + public constructor MyMap() + public abstract override /*1*/ /*fake_override*/ val entries: kotlin.collections.MutableSet> + invisible_fake final override /*1*/ /*fake_override*/ var keySet: kotlin.collections.(Mutable)Set! + public open override /*1*/ /*fake_override*/ val keys: kotlin.collections.MutableSet + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var values: kotlin.collections.(Mutable)Collection! + public open override /*1*/ /*fake_override*/ val values: kotlin.collections.MutableCollection + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: kotlin.Double!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: kotlin.CharSequence!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open override /*1*/ fun get(/*0*/ key: kotlin.Double!): kotlin.String? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: kotlin.Double!, /*1*/ value: kotlin.CharSequence!): kotlin.CharSequence? + public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ from: kotlin.collections.Map): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.Double!): kotlin.CharSequence? + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake open override /*1*/ /*fake_override*/ fun eq(/*0*/ p0: kotlin.Any!, /*1*/ p1: kotlin.Any!): kotlin.Boolean +} diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt index 54302d47afd..c357b29c46a 100644 --- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_VALUE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE +// JAVAC_EXPECTED_FILE // FILE: MyMap.java abstract public class MyMap extends java.util.AbstractMap { diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.javac.txt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.javac.txt new file mode 100644 index 00000000000..5e630e2f892 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.javac.txt @@ -0,0 +1,76 @@ +package + +public fun main(/*0*/ a: A, /*1*/ b: B, /*2*/ c: java.util.ArrayList): kotlin.Unit + +public abstract class A : B { + public constructor A() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: F!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: F!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: F!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): F! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: F!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: F!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ fun remove(/*0*/ element: F!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ fun removeAt(/*0*/ x: kotlin.Int): F! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: F!): F! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} + +public abstract class B : kotlin.collections.MutableList, java.util.AbstractList { + public constructor B() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*2*/ /*fake_override*/ val size: kotlin.Int + public open override /*2*/ /*fake_override*/ fun add(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun contains(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*2*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): T + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun indexOf(/*0*/ element: T): kotlin.Int + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*2*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T): kotlin.Int + public open override /*2*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*2*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ fun remove(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ fun removeAt(/*0*/ index: kotlin.Int): T + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T): T + public open override /*2*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt index 171f9360072..bf5a5332a11 100644 --- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: A.java abstract public class A extends B { public F remove(int x) { } diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt new file mode 100644 index 00000000000..89cff7b6c76 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt @@ -0,0 +1,76 @@ +package + +public fun main(/*0*/ a: A, /*1*/ b: B, /*2*/ c: java.util.ArrayList): kotlin.Unit + +public abstract class A : B { + public constructor A() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ fun remove(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ fun removeAt(/*0*/ index: kotlin.Int): kotlin.Int + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} + +public abstract class B : kotlin.collections.MutableList, java.util.AbstractList { + public constructor B() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*2*/ /*fake_override*/ val size: kotlin.Int + public open override /*2*/ /*fake_override*/ fun add(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*2*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.Int + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.Int): kotlin.Int + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*2*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.Int): kotlin.Int + public open override /*2*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*2*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ fun remove(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ fun removeAt(/*0*/ index: kotlin.Int): kotlin.Int + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int): kotlin.Int + public open override /*2*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt index 76af6ae284f..90ecc2b0a35 100644 --- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: A.java abstract public class A extends B { public Integer removeAt(int x) { } diff --git a/compiler/testData/diagnostics/tests/j+k/differentFilename.kt b/compiler/testData/diagnostics/tests/j+k/differentFilename.kt index bcd78450d20..c42a86022bf 100644 --- a/compiler/testData/diagnostics/tests/j+k/differentFilename.kt +++ b/compiler/testData/diagnostics/tests/j+k/differentFilename.kt @@ -1,3 +1,4 @@ +// JAVAC_SKIP // FILE: A.java public class A { public B b() {} diff --git a/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.javac.txt b/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.javac.txt new file mode 100644 index 00000000000..49c5cc9f36b --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.javac.txt @@ -0,0 +1,106 @@ +package + +public abstract class A : java.util.ArrayList { + public constructor A() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public final override /*1*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val DEFAULT_CAPACITY: kotlin.Int = 10 + invisible_fake final override /*1*/ /*fake_override*/ val EMPTY_ELEMENTDATA: kotlin.Array<(out) kotlin.Any!>! + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake const final override /*1*/ /*fake_override*/ val serialVersionUID: kotlin.Long = 8683452581122892189.toLong() + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun subListRangeCheck(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Unit +} + +public final class B : A { + public constructor B() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public open override /*1*/ val size: kotlin.Int = 1 + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt b/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt index e1596e74991..fc53d7be086 100644 --- a/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt +++ b/compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: A.java abstract public class A extends java.util.ArrayList { diff --git a/compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.txt b/compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.txt index 93c8f123813..d8a0bc14617 100644 --- a/compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.txt +++ b/compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.txt @@ -1,5 +1,43 @@ package +package a { + + public open class M { + public constructor M() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Inner { + public constructor Inner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Nested { + public constructor Nested() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + private open inner class PrInner { + private constructor PrInner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + private open class PrNested { + private constructor PrNested() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + package b { public fun f(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.txt b/compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.txt index 054a9e2c569..a2c5c97d04e 100644 --- a/compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.txt +++ b/compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.txt @@ -1,5 +1,27 @@ package +package a { + + public open class M { + public constructor M() + public/*package*/ final var m: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + + public open class F : a.M { + public constructor F() + invisible_fake final override /*1*/ /*fake_override*/ var m: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + package c { public fun f(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/j+k/javaStaticImport.javac.txt b/compiler/testData/diagnostics/tests/j+k/javaStaticImport.javac.txt new file mode 100644 index 00000000000..3ee0e7a912e --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/javaStaticImport.javac.txt @@ -0,0 +1,30 @@ +package + +package backend { + + public open class ECallable { + public constructor ECallable() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final fun test(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package frontend { + + public final class JvmDeclarationOrigin { + public constructor JvmDeclarationOrigin() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public final val NO_ORIGIN: frontend.JvmDeclarationOrigin + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt b/compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt index ce86bd30e39..72f4f0629bd 100644 --- a/compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt +++ b/compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: backend/asmutil/AsmUtil.java package backend.asmutil; diff --git a/compiler/testData/diagnostics/tests/j+k/kt1402.txt b/compiler/testData/diagnostics/tests/j+k/kt1402.txt index 745981fc16d..3a96d74ed43 100644 --- a/compiler/testData/diagnostics/tests/j+k/kt1402.txt +++ b/compiler/testData/diagnostics/tests/j+k/kt1402.txt @@ -1,5 +1,24 @@ package +package a { + + public open class M { + public constructor M() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Inner { + public constructor Inner(/*0*/ i: kotlin.Int) + private final var i: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + package b { public fun doSmth(/*0*/ b: a.M.Inner): a.M.Inner public fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/j+k/kt1431.txt b/compiler/testData/diagnostics/tests/j+k/kt1431.txt index 34323b84aa5..c3054d1ab26 100644 --- a/compiler/testData/diagnostics/tests/j+k/kt1431.txt +++ b/compiler/testData/diagnostics/tests/j+k/kt1431.txt @@ -1,5 +1,19 @@ package +package a { + + public open class C!> { + public constructor C!>() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(): a.C<(raw) a.C<*>!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun create(): a.C<*>! + } +} + package d { public fun test(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/j+k/mutableIterator.txt b/compiler/testData/diagnostics/tests/j+k/mutableIterator.txt index 3210f7895da..6e1b9a1c10b 100644 --- a/compiler/testData/diagnostics/tests/j+k/mutableIterator.txt +++ b/compiler/testData/diagnostics/tests/j+k/mutableIterator.txt @@ -1,5 +1,18 @@ package +package a { + + public interface JC { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun getIterable(): kotlin.collections.(Mutable)Iterable! + public abstract fun getIterator(): kotlin.collections.(Mutable)Iterator! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract fun setIterable(/*0*/ iterable: kotlin.collections.(Mutable)Iterable!): kotlin.Unit + public abstract fun setIterator(/*0*/ iterator: kotlin.collections.(Mutable)Iterator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + package n { public fun foo(/*0*/ c: a.JC, /*1*/ iterator: kotlin.collections.Iterator, /*2*/ iterable: kotlin.collections.Iterable): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.javac.txt b/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.javac.txt new file mode 100644 index 00000000000..a08916f0978 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.javac.txt @@ -0,0 +1,76 @@ +package + +public fun test(): kotlin.Unit + +public open class A : java.util.HashMap, B { + public constructor A() + public open override /*1*/ /*fake_override*/ val entries: kotlin.collections.MutableSet> + invisible_fake final override /*1*/ /*fake_override*/ var entrySet: kotlin.collections.(Mutable)Set!>! + invisible_fake final override /*1*/ /*fake_override*/ var hashSeed: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var keySet: kotlin.collections.(Mutable)Set! + public open override /*1*/ /*fake_override*/ val keys: kotlin.collections.MutableSet + invisible_fake final override /*1*/ /*fake_override*/ val loadFactor: kotlin.Float + invisible_fake final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var table: kotlin.Array<(out) java.util.HashMap.Entry!>! + invisible_fake final override /*1*/ /*fake_override*/ var threshold: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var values: kotlin.collections.(Mutable)Collection! + public open override /*1*/ /*fake_override*/ val values: kotlin.collections.MutableCollection + invisible_fake open override /*1*/ /*fake_override*/ fun addEntry(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int!, /*2*/ p2: kotlin.Double!, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun capacity(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: kotlin.Int!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun containsNullValue(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: kotlin.Double!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun createEntry(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int!, /*2*/ p2: kotlin.Double!, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun entrySet0(): kotlin.collections.(Mutable)Set!>! + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun get(/*0*/ key: kotlin.Int!): kotlin.Double? + invisible_fake final override /*1*/ /*fake_override*/ fun getEntry(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry! + invisible_fake open override /*1*/ /*fake_override*/ fun getForNullKey(): kotlin.Double! + invisible_fake final override /*1*/ /*fake_override*/ fun hash(/*0*/ p0: kotlin.Any!): kotlin.Int + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun inflateTable(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun init(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun initHashSeedAsNeeded(/*0*/ p0: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun loadFactor(): kotlin.Float + invisible_fake open override /*1*/ /*fake_override*/ fun newEntryIterator(): kotlin.collections.(Mutable)Iterator!>! + invisible_fake open override /*1*/ /*fake_override*/ fun newKeyIterator(): kotlin.collections.(Mutable)Iterator! + invisible_fake open override /*1*/ /*fake_override*/ fun newValueIterator(): kotlin.collections.(Mutable)Iterator! + public open override /*1*/ fun put(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Double): kotlin.Double + @java.lang.Override public open override /*2*/ fun put(/*0*/ key: kotlin.Int!, /*1*/ value: kotlin.Double!): kotlin.Double? + public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ from: kotlin.collections.Map): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun putAllForCreate(/*0*/ p0: (kotlin.collections.MutableMap..kotlin.collections.Map?)): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun putForCreate(/*0*/ p0: kotlin.Int!, /*1*/ p1: kotlin.Double!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun putForNullKey(/*0*/ p0: kotlin.Double!): kotlin.Double! + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: kotlin.Int!): kotlin.Double? + invisible_fake final override /*1*/ /*fake_override*/ fun removeEntryForKey(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry! + invisible_fake final override /*1*/ /*fake_override*/ fun removeMapping(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry! + invisible_fake open override /*1*/ /*fake_override*/ fun resize(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + invisible_fake open override /*1*/ /*fake_override*/ fun transfer(/*0*/ p0: kotlin.Array<(out) java.util.HashMap.Entry<(raw) kotlin.Any!, (raw) kotlin.Any!>!>!, /*1*/ p1: kotlin.Boolean): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val ALTERNATIVE_HASHING_THRESHOLD_DEFAULT: kotlin.Int = 2147483647 + invisible_fake const final override /*1*/ /*fake_override*/ val DEFAULT_INITIAL_CAPACITY: kotlin.Int = 16 + invisible_fake const final override /*1*/ /*fake_override*/ val DEFAULT_LOAD_FACTOR: kotlin.Float = 0.75.toFloat() + invisible_fake final override /*1*/ /*fake_override*/ val EMPTY_TABLE: kotlin.Array<(out) java.util.HashMap.Entry<*, *>!>! + invisible_fake const final override /*1*/ /*fake_override*/ val MAXIMUM_CAPACITY: kotlin.Int = 1073741824 + invisible_fake const final override /*1*/ /*fake_override*/ val serialVersionUID: kotlin.Long = 362498820763181265.toLong() + invisible_fake open override /*1*/ /*fake_override*/ fun eq(/*0*/ p0: kotlin.Any!, /*1*/ p1: kotlin.Any!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun indexFor(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun roundUpToPowerOf2(/*0*/ p0: kotlin.Int): kotlin.Int +} + +public interface B { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract fun put(/*0*/ x: T1!, /*1*/ y: T2!): T2! + public abstract fun put(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Double): kotlin.Double + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt b/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt index 9fc2f5446c7..748414ef3b5 100644 --- a/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt +++ b/compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: B.java public interface B { double put(int x, double y); diff --git a/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.txt b/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.txt index 49ba831837b..c924771988b 100644 --- a/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.txt +++ b/compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.txt @@ -1,3 +1,23 @@ package public fun main(/*0*/ args: kotlin.Array): kotlin.Unit + +package javaPackage { + + public open class Foo { + public constructor Foo() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + private open class Bar { + private constructor Bar() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun doSmth(): kotlin.Unit + } + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.javac.txt b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.javac.txt new file mode 100644 index 00000000000..4f7a3d9818e --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.javac.txt @@ -0,0 +1,25 @@ +package + +package bar { + public fun main(): kotlin.Unit +} + +package foo { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public interface B { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun g(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + // Static members + public/*package*/ open fun f(/*0*/ b: foo.A.B!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt index 65dc762fb25..26d15658ffa 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt +++ b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: foo/A.java package foo; diff --git a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.txt b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.txt index a46f4432d26..4f7a3d9818e 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.txt +++ b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.txt @@ -3,3 +3,23 @@ package package bar { public fun main(): kotlin.Unit } + +package foo { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public interface B { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun g(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + // Static members + public/*package*/ open fun f(/*0*/ b: foo.A.B!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.txt b/compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.txt index f725186033d..ab633813a42 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.txt +++ b/compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.txt @@ -1,5 +1,18 @@ package +package a { + + public open class Statics { + public constructor Statics() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun foo(/*0*/ r: java.lang.Runnable!): kotlin.Unit + } +} + package b { public fun test(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.txt b/compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.txt index f725186033d..ab633813a42 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.txt +++ b/compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.txt @@ -1,5 +1,18 @@ package +package a { + + public open class Statics { + public constructor Statics() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun foo(/*0*/ r: java.lang.Runnable!): kotlin.Unit + } +} + package b { public fun test(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.txt b/compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.txt index 1ae9bc51425..4620aca7bd1 100644 --- a/compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.txt +++ b/compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.txt @@ -13,3 +13,20 @@ public final class K : j.Observable { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package j { + + public open class Observable { + protected/*protected and package*/ constructor Observable(/*0*/ f: j.OnSubscribe!) + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface OnSubscribe { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun f(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/serializable.txt b/compiler/testData/diagnostics/tests/j+k/serializable.txt index cecb15122ad..c2f17d08e83 100644 --- a/compiler/testData/diagnostics/tests/j+k/serializable.txt +++ b/compiler/testData/diagnostics/tests/j+k/serializable.txt @@ -41,3 +41,17 @@ public final class S : java.io.Serializable { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package aa { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun use(/*0*/ s: java.io.Serializable!): kotlin.Unit + public open fun useList(/*0*/ s: (kotlin.collections.MutableList..kotlin.collections.List?)): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt b/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt index e6c54b067c5..e8f1faa87c9 100644 --- a/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt +++ b/compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.txt @@ -1,3 +1,26 @@ package public fun use(): kotlin.Unit + +package aa { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public final var CONST: kotlin.Int + } + + public open class B : aa.A { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public final var CONST: kotlin.String! + } +} diff --git a/compiler/testData/diagnostics/tests/j+k/specialBridges.javac.txt b/compiler/testData/diagnostics/tests/j+k/specialBridges.javac.txt new file mode 100644 index 00000000000..d179237a3c7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/specialBridges.javac.txt @@ -0,0 +1,56 @@ +package + +public final class B2 : java.util.ArrayList, I2 { + public constructor B2() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*2*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.String + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} + +public interface I2 { + public abstract val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/specialBridges.kt b/compiler/testData/diagnostics/tests/j+k/specialBridges.kt index bc8ab570cc0..f83c28a9a99 100644 --- a/compiler/testData/diagnostics/tests/j+k/specialBridges.kt +++ b/compiler/testData/diagnostics/tests/j+k/specialBridges.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE interface I2 { val size: Int } diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt index e753cb09e46..e4f52d51354 100644 --- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt @@ -1,4 +1,5 @@ -@myAnnotation public package illegal_modifiers +@myAnnotation public +package illegal_modifiers abstract class A() { abstract final fun f() diff --git a/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt b/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt index f37808091db..32527db7597 100644 --- a/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt +++ b/compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt @@ -20,19 +20,19 @@ interface JSuper2 { // FILE: Sub1.java interface Sub1 extends KSuper, JSuper1, JSuper2 { @Override - void foo(int sub1Name) + void foo(int sub1Name); } // FILE: Sub2.java interface Sub2 extends JSuper1, KSuper, JSuper2 { @Override - void foo(int sub2Name) + void foo(int sub2Name); } // FILE: Sub3.java interface Sub3 extends JSuper1, JSuper2, KSuper { @Override - void foo(int sub3Name) + void foo(int sub3Name); } diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.txt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.txt index 180d26b56ea..61587ae35b2 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.txt @@ -2,3 +2,16 @@ package public fun test(/*0*/ b: kotlin.Boolean): kotlin.Unit public fun T.foo(): kotlin.Unit + +package p { + + public open class Utils { + public constructor Utils() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun c(): kotlin.collections.(Mutable)Collection! + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.txt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.txt index 45f944c43b0..38a678ac6dd 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.txt @@ -3,3 +3,30 @@ package public fun listOf(/*0*/ t: T): kotlin.collections.List public fun test(): kotlin.Unit public fun kotlin.collections.Collection.foo(): T + +package p { + + public open class Other { + public constructor Other() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public final var sub: p.Sub! + public final var subs: kotlin.collections.(Mutable)Collection! + public final var supers: kotlin.collections.(Mutable)Collection! + } + + public interface Sub : p.Super { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Super { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.txt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.txt index 15e95995a2f..633e49e998d 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.txt @@ -1,3 +1,16 @@ package public fun foo(/*0*/ j: p.J): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun j(): p.J! + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.txt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.txt index 4cbd1406f3e..cd810ce4df6 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.txt @@ -1,3 +1,24 @@ package public fun test(/*0*/ a: p.A, /*1*/ b: p.B, /*2*/ c: kotlin.Boolean): kotlin.Unit + +package p { + + public interface A : p.Rec { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface B : p.Rec { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Rec { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.txt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.txt index 180d26b56ea..40e4b1b4c81 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.txt @@ -2,3 +2,16 @@ package public fun test(/*0*/ b: kotlin.Boolean): kotlin.Unit public fun T.foo(): kotlin.Unit + +package p { + + public open class Utils { + public constructor Utils() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun str(): kotlin.String! + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.txt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.txt index d903b0681df..df7ac041bc1 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.txt @@ -2,3 +2,16 @@ package public fun foo(): p.J? public fun main(/*0*/ args: kotlin.Array): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun j(): p.J! + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/dereference.txt b/compiler/testData/diagnostics/tests/platformTypes/dereference.txt index 887467007e0..d65b933cd95 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/dereference.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/dereference.txt @@ -1,3 +1,16 @@ package public fun test(/*0*/ j: p.J): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(): T! + public open fun foo1(): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun j(): p.J! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/elvis.txt b/compiler/testData/diagnostics/tests/platformTypes/elvis.txt index 887467007e0..7bfaebf36d2 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/elvis.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/elvis.txt @@ -1,3 +1,14 @@ package public fun test(/*0*/ j: p.J): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun s(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/getParentOfType.txt b/compiler/testData/diagnostics/tests/platformTypes/getParentOfType.txt index 7402ce66dd4..fe2c3af9df0 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/getParentOfType.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/getParentOfType.txt @@ -2,3 +2,29 @@ package public fun javaClass(): java.lang.Class public fun test(/*0*/ e: p.JetExpression): kotlin.Unit + +package p { + + public interface JetExpression : p.PsiElement { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface PsiElement { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Util { + public constructor Util() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun getParentOfType(/*0*/ @Nullable /* annotation class not found */ element: p.PsiElement!, /*1*/ @NotNull /* annotation class not found */ aClass: java.lang.Class!): T! + public open fun on(/*0*/ e: p.JetExpression!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/inference.txt b/compiler/testData/diagnostics/tests/platformTypes/inference.txt index 4af0be09d77..ab143f4cb8f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/inference.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/inference.txt @@ -2,3 +2,19 @@ package public fun > convert(/*0*/ src: foo.HS, /*1*/ dest: C): C public fun test(/*0*/ l: foo.HS): kotlin.Unit + +package foo { + + public interface Base { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class HS : foo.Base { + public constructor HS() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.txt b/compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.txt index 0708a83689e..b703418e906 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.txt @@ -9,3 +9,30 @@ public final class C { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public interface A { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface B { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + // Static members + public open fun foo(/*0*/ s: kotlin.Int): p.J.A! + public open fun foo(/*0*/ s: kotlin.Int!): p.J.B! + public open fun getInteger(): kotlin.Int! + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt b/compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt index 960988f0aaa..a31eb896c2f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt @@ -1,7 +1,7 @@ // !CHECK_TYPE // FILE: Collections.java -import java.util.List +import java.util.List; public class Collections { public static final List emptyList() { diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.txt index 93e27f34c8c..37a74e9daec 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.txt @@ -1,3 +1,14 @@ package public fun test(): kotlin.Unit + +package p { + + public open class MultiMap { + public constructor MultiMap() + public open fun entrySet(): kotlin.collections.(Mutable)Set!>! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.txt index 6f4de93e23d..d719e97db3c 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.txt @@ -1,3 +1,24 @@ package public fun main(/*0*/ j: p.J): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(/*0*/ r: p.Ref!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Ref { + public constructor Ref() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun create(): p.Ref! + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.txt index 93e27f34c8c..9c50fbae3ae 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/int.txt @@ -1,3 +1,14 @@ package public fun test(): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open fun _int(/*0*/ s: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.txt index 7bb119cf9db..6d9f306635f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.txt @@ -1,3 +1,14 @@ package public fun test(/*0*/ ia: kotlin.IntArray): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun intArr(/*0*/ s: kotlin.IntArray!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.txt index 887467007e0..9a47990a384 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.txt @@ -1,3 +1,15 @@ package public fun test(/*0*/ j: p.J): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun list(): java.util.ArrayList! + public open fun takeList(/*0*/ list: java.util.ArrayList!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.txt index 554395715c0..60a661bef9e 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.txt @@ -2,3 +2,14 @@ package public fun takeJ(/*0*/ j: p.J): kotlin.Unit public fun test(): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun j(): p.J! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/list.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/list.txt index abf7a9ec0da..9d294f2d9b1 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/list.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/list.txt @@ -1,3 +1,14 @@ package public fun test(/*0*/ ls: kotlin.collections.List, /*1*/ mls: kotlin.collections.MutableList, /*2*/ lsn: kotlin.collections.List, /*3*/ mlsn: kotlin.collections.MutableList?): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun list(/*0*/ s: kotlin.collections.(Mutable)List!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.javac.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.javac.txt new file mode 100644 index 00000000000..05295e0be07 --- /dev/null +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.javac.txt @@ -0,0 +1,50 @@ +package + +public fun foo(/*0*/ delegateResolver: ResolverForProject): ResolverForProject + +public/*package*/ open class MyMap : java.util.AbstractMap { + public/*package*/ constructor MyMap() + public open override /*1*/ val entries: kotlin.collections.MutableSet> + invisible_fake final override /*1*/ /*fake_override*/ var keySet: kotlin.collections.(Mutable)Set! + public open override /*1*/ /*fake_override*/ val keys: kotlin.collections.MutableSet + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var values: kotlin.collections.(Mutable)Collection! + public open override /*1*/ /*fake_override*/ val values: kotlin.collections.MutableCollection + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: K!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: V!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun get(/*0*/ key: K!): V? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: K!, /*1*/ value: V!): V? + public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ from: kotlin.collections.Map): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: K!): V? + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake open override /*1*/ /*fake_override*/ fun eq(/*0*/ p0: kotlin.Any!, /*1*/ p1: kotlin.Any!): kotlin.Boolean +} + +public interface ResolverForProject { + public open val exposeM: M1 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class ResolverForProjectImpl : ResolverForProject { + public constructor ResolverForProjectImpl(/*0*/ descriptorByModule: kotlin.collections.Map, /*1*/ delegateResolver: ResolverForProject) + public open override /*1*/ /*fake_override*/ val exposeM: M + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public interface WithFoo { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt index 60141117617..61756c2e436 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: MyMap.java import java.util.AbstractMap; diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.txt index dfa47b8062b..ddfc6500558 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.txt @@ -1,3 +1,14 @@ package public fun test(/*0*/ aa: kotlin.Array, /*1*/ sa: kotlin.Array, /*2*/ san: kotlin.Array): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open fun arr(/*0*/ s: kotlin.Array<(out) kotlin.Any!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt index fdef1520e3f..d15ca76f0a5 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt @@ -13,7 +13,7 @@ public interface Sub extends Super {} package p; public abstract class Util { - public abstract void foo(String s, Super sup) + public abstract void foo(String s, Super sup); public void foo(String s, Sub sub) {} } @@ -27,4 +27,4 @@ class C: Util() { fun foo(sub: Sub) { C().foo("", sub) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.txt index bdf4b3e2299..309ea608483 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.txt @@ -10,3 +10,27 @@ public final class C : p.Util { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package p { + + public interface Sub : p.Super { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Super { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public abstract class Util { + public constructor Util() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(/*0*/ s: kotlin.String!, /*1*/ sub: p.Sub!): kotlin.Unit + public abstract fun foo(/*0*/ s: kotlin.String!, /*1*/ sup: p.Super!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.txt index 93e27f34c8c..335b2f5ef27 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.txt @@ -1,3 +1,23 @@ package public fun test(): kotlin.Unit + +package p { + + public interface SAM { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun foo(): R! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Util { + public constructor Util() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun sam(/*0*/ sam: p.SAM!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/string.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/string.txt index 93e27f34c8c..a88e90f96e2 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/string.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/string.txt @@ -1,3 +1,14 @@ package public fun test(): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun str(/*0*/ s: p.J!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.txt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.txt index 6600798d1e6..d5a7035263f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.txt @@ -1,3 +1,20 @@ package public fun test(/*0*/ v: p.Visitor, /*1*/ e: p.Element): kotlin.Unit + +package p { + + public open class Element { + public constructor Element() + public open fun accept(/*0*/ @org.jetbrains.annotations.NotNull visitor: p.Visitor, /*1*/ data: D!): R! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Visitor { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/override.kt b/compiler/testData/diagnostics/tests/platformTypes/override.kt index 86c6f6179ea..bf7c372a64f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/override.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/override.kt @@ -2,7 +2,7 @@ package p; -import p.J.Param +import p.J.Param; public interface I { String s(); @@ -23,4 +23,4 @@ fun test() { val s = J().s() s.get(0) s!!.get(0) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/override.txt b/compiler/testData/diagnostics/tests/platformTypes/override.txt index 93e27f34c8c..a948f0d4a98 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/override.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/override.txt @@ -1,3 +1,21 @@ package public fun test(): kotlin.Unit + +package p { + + public interface I { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract fun s(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class J : p.I { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ fun s(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt index 566dbd6be6d..3a7ff83d6dc 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt @@ -5,7 +5,7 @@ import java.util.*; class A { - void foo(T x) + void foo(T x) {} public class Inner { Inner(E x0, T x, List y) {} diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt index d765af63866..302f3976a29 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt @@ -1,5 +1,5 @@ // FILE: B.java -import java.util.List +import java.util.List; public class B implements X { @Override @@ -14,4 +14,4 @@ interface X { fun foo(l: MutableList): List? } -internal class C : B() \ No newline at end of file +internal class C : B() diff --git a/compiler/testData/diagnostics/tests/platformTypes/safeCall.txt b/compiler/testData/diagnostics/tests/platformTypes/safeCall.txt index 887467007e0..7bfaebf36d2 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/safeCall.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/safeCall.txt @@ -1,3 +1,14 @@ package public fun test(/*0*/ j: p.J): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun s(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/samConstructor.txt b/compiler/testData/diagnostics/tests/platformTypes/samConstructor.txt index 93e27f34c8c..f02b5c1dc5d 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/samConstructor.txt +++ b/compiler/testData/diagnostics/tests/platformTypes/samConstructor.txt @@ -1,3 +1,16 @@ package public fun test(): kotlin.Unit + +package p { + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun c(/*0*/ c: java.util.Comparator!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.javac.txt b/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.javac.txt new file mode 100644 index 00000000000..9653c35959e --- /dev/null +++ b/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.javac.txt @@ -0,0 +1,68 @@ +package + +public interface ExtMap : kotlin.collections.Map { + public abstract override /*1*/ /*fake_override*/ val entries: kotlin.collections.Set> + public abstract override /*1*/ /*fake_override*/ val keys: kotlin.collections.Set + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val values: kotlin.collections.Collection + public abstract override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key: K): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value: V): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ key: K): V? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class HashMapEx : java.util.HashMap, ExtMap { + public constructor HashMapEx() + public open override /*2*/ /*fake_override*/ val entries: kotlin.collections.MutableSet> + invisible_fake final override /*1*/ /*fake_override*/ var entrySet: kotlin.collections.(Mutable)Set!>! + invisible_fake final override /*1*/ /*fake_override*/ var hashSeed: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var keySet: kotlin.collections.(Mutable)Set! + public open override /*2*/ /*fake_override*/ val keys: kotlin.collections.MutableSet + invisible_fake final override /*1*/ /*fake_override*/ val loadFactor: kotlin.Float + invisible_fake final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*2*/ /*fake_override*/ val size: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var table: kotlin.Array<(out) java.util.HashMap.Entry!>! + invisible_fake final override /*1*/ /*fake_override*/ var threshold: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var values: kotlin.collections.(Mutable)Collection! + public open override /*2*/ /*fake_override*/ val values: kotlin.collections.MutableCollection + invisible_fake open override /*1*/ /*fake_override*/ fun addEntry(/*0*/ p0: kotlin.Int, /*1*/ p1: K!, /*2*/ p2: V!, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun capacity(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*2*/ /*fake_override*/ fun containsKey(/*0*/ key: K): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun containsNullValue(): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun containsValue(/*0*/ value: V): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun createEntry(/*0*/ p0: kotlin.Int, /*1*/ p1: K!, /*2*/ p2: V!, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun entrySet0(): kotlin.collections.(Mutable)Set!>! + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun get(/*0*/ key: K): V? + invisible_fake final override /*1*/ /*fake_override*/ fun getEntry(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry! + invisible_fake open override /*1*/ /*fake_override*/ fun getForNullKey(): V! + invisible_fake final override /*1*/ /*fake_override*/ fun hash(/*0*/ p0: kotlin.Any!): kotlin.Int + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun inflateTable(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun init(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun initHashSeedAsNeeded(/*0*/ p0: kotlin.Int): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun loadFactor(): kotlin.Float + invisible_fake open override /*1*/ /*fake_override*/ fun newEntryIterator(): kotlin.collections.(Mutable)Iterator!>! + invisible_fake open override /*1*/ /*fake_override*/ fun newKeyIterator(): kotlin.collections.(Mutable)Iterator! + invisible_fake open override /*1*/ /*fake_override*/ fun newValueIterator(): kotlin.collections.(Mutable)Iterator! + public open override /*1*/ /*fake_override*/ fun put(/*0*/ key: K, /*1*/ value: V): V? + public open override /*1*/ /*fake_override*/ fun putAll(/*0*/ from: kotlin.collections.Map): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun putAllForCreate(/*0*/ p0: (kotlin.collections.MutableMap..kotlin.collections.Map?)): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun putForCreate(/*0*/ p0: K!, /*1*/ p1: V!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun putForNullKey(/*0*/ p0: V!): V! + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ key: K): V? + invisible_fake final override /*1*/ /*fake_override*/ fun removeEntryForKey(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry! + invisible_fake final override /*1*/ /*fake_override*/ fun removeMapping(/*0*/ p0: kotlin.Any!): java.util.HashMap.Entry! + invisible_fake open override /*1*/ /*fake_override*/ fun resize(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + invisible_fake open override /*1*/ /*fake_override*/ fun transfer(/*0*/ p0: kotlin.Array<(out) java.util.HashMap.Entry<(raw) kotlin.Any!, (raw) kotlin.Any!>!>!, /*1*/ p1: kotlin.Boolean): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt b/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt index 6554d91e6e0..899414d61cc 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt @@ -1,2 +1,3 @@ +// JAVAC_EXPECTED_FILE interface ExtMap : Map class HashMapEx : java.util.HashMap(), ExtMap \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt b/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt index b6fc44dbeb4..8ae5b50d09e 100644 --- a/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt +++ b/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt @@ -1,3 +1,4 @@ +// JAVAC_SKIP // FILE: p/Nameless.java package p; diff --git a/compiler/testData/diagnostics/tests/recovery/namelessInJava.txt b/compiler/testData/diagnostics/tests/recovery/namelessInJava.txt index bfa0e3ff90e..acea0b00e1f 100644 --- a/compiler/testData/diagnostics/tests/recovery/namelessInJava.txt +++ b/compiler/testData/diagnostics/tests/recovery/namelessInJava.txt @@ -8,3 +8,13 @@ public final class K : p.Nameless { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package p { + + public open class Nameless { + public/*package*/ constructor Nameless() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt16086.javac.txt b/compiler/testData/diagnostics/tests/regressions/kt16086.javac.txt new file mode 100644 index 00000000000..724b148b4b3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/regressions/kt16086.javac.txt @@ -0,0 +1,36 @@ +package + +package com { + + package com.winterbe { + + package com.winterbe.observer { + + public abstract class Observer : kotlin.collections.List { + public constructor Observer() + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: com.winterbe.domain.IEntity): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): com.winterbe.domain.IEntity + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: com.winterbe.domain.IEntity): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.Iterator + public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: com.winterbe.domain.IEntity): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.ListIterator + public abstract override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.ListIterator + public abstract override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.List + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class ObserverSupport { + public constructor ObserverSupport(/*0*/ observers: kotlin.collections.List) + private final val observers: kotlin.collections.List + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt16086.kt b/compiler/testData/diagnostics/tests/regressions/kt16086.kt index c1bcfe19a18..54173a9811c 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt16086.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt16086.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: com/winterbe/domain/IEntity.java package com.winterbe.domain; import com.winterbe.observer.ObserverSupport; diff --git a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.javac.txt b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.javac.txt new file mode 100644 index 00000000000..cd9456d483b --- /dev/null +++ b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.javac.txt @@ -0,0 +1,669 @@ +package + +package test { + + public final class KFrame : javax.swing.JFrame { + public constructor KFrame() + invisible_fake final override /*1*/ /*fake_override*/ var acc: java.security.AccessControlContext! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var accessibleContext: javax.accessibility.AccessibleContext! + invisible_fake final override /*1*/ /*fake_override*/ var alwaysOnTop: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var anchor: kotlin.Any! + invisible_fake final override /*1*/ /*fake_override*/ var appContext: sun.awt.AppContext! + invisible_fake final override /*1*/ /*fake_override*/ var autoFocusTransferOnDisposal: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var autoRequestFocus: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var background: java.awt.Color! + invisible_fake final override /*1*/ /*fake_override*/ var backgroundEraseDisabled: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var beforeFirstShow: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var boundsOp: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var bufferStrategy: java.awt.image.BufferStrategy! + invisible_fake final override /*1*/ /*fake_override*/ var changeSupport: java.beans.PropertyChangeSupport! + invisible_fake final override /*1*/ /*fake_override*/ var coalescingEnabled: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var component: kotlin.collections.(Mutable)List! + invisible_fake final override /*1*/ /*fake_override*/ var componentListener: java.awt.event.ComponentListener! + invisible_fake final override /*1*/ /*fake_override*/ var componentOrientation: java.awt.ComponentOrientation! + invisible_fake final override /*1*/ /*fake_override*/ var componentSerializedDataVersion: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var compoundShape: sun.java2d.pipe.Region! + invisible_fake final override /*1*/ /*fake_override*/ var containerListener: java.awt.event.ContainerListener! + invisible_fake final override /*1*/ /*fake_override*/ var containerSerializedDataVersion: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var cursor: java.awt.Cursor! + invisible_fake final override /*1*/ /*fake_override*/ var defaultCloseOperation: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var descendantsCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var dispatcher: java.awt.LightweightDispatcher! + invisible_fake final override /*1*/ /*fake_override*/ var disposing: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var dropTarget: java.awt.dnd.DropTarget! + invisible_fake final override /*1*/ /*fake_override*/ var enabled: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var eventCache: kotlin.Array<(out) sun.awt.EventQueueItem!>! + invisible_fake final override /*1*/ /*fake_override*/ var eventMask: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var focusCycleRoot: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var focusListener: java.awt.event.FocusListener! + invisible_fake final override /*1*/ /*fake_override*/ var focusMgr: java.awt.FocusManager! + invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalKeys: kotlin.Array<(out) kotlin.collections.(Mutable)Set<(raw) kotlin.Any?>!>! + invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalKeysEnabled: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalPolicy: java.awt.FocusTraversalPolicy! + invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalPolicyProvider: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var focusable: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var focusableWindowState: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var font: java.awt.Font! + invisible_fake final override /*1*/ /*fake_override*/ var foreground: java.awt.Color! + invisible_fake final override /*1*/ /*fake_override*/ var frameSerializedDataVersion: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var graphicsConfig: java.awt.GraphicsConfiguration! + invisible_fake final override /*1*/ /*fake_override*/ var height: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var hierarchyBoundsListener: java.awt.event.HierarchyBoundsListener! + invisible_fake final override /*1*/ /*fake_override*/ var hierarchyListener: java.awt.event.HierarchyListener! + invisible_fake final override /*1*/ /*fake_override*/ var icons: kotlin.collections.(Mutable)List! + invisible_fake final override /*1*/ /*fake_override*/ var ignoreRepaint: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var inputContext: java.awt.im.InputContext! + invisible_fake final override /*1*/ /*fake_override*/ var inputContextLock: kotlin.Any! + invisible_fake final override /*1*/ /*fake_override*/ var inputMethodListener: java.awt.event.InputMethodListener! + invisible_fake final override /*1*/ /*fake_override*/ var isAddNotifyComplete: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var isFocusTraversableOverridden: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var isInShow: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var isPacked: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var isTrayIconWindow: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var keyListener: java.awt.event.KeyListener! + invisible_fake final override /*1*/ /*fake_override*/ var layoutMgr: java.awt.LayoutManager! + invisible_fake final override /*1*/ /*fake_override*/ var listeningBoundsChildren: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var listeningChildren: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var locale: java.util.Locale! + invisible_fake final override /*1*/ /*fake_override*/ var locationByPlatform: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var maxSize: java.awt.Dimension! + invisible_fake final override /*1*/ /*fake_override*/ var maxSizeSet: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var maximizedBounds: java.awt.Rectangle! + invisible_fake final override /*1*/ /*fake_override*/ var mbManagement: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var menuBar: java.awt.MenuBar! + invisible_fake final override /*1*/ /*fake_override*/ var minSize: java.awt.Dimension! + invisible_fake final override /*1*/ /*fake_override*/ var minSizeSet: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var mixingCutoutRegion: sun.java2d.pipe.Region! + invisible_fake final override /*1*/ /*fake_override*/ var modalAppContext: sun.awt.AppContext! + invisible_fake final override /*1*/ /*fake_override*/ var modalBlocker: java.awt.Dialog! + invisible_fake final override /*1*/ /*fake_override*/ var modalComp: java.awt.Component! + invisible_fake final override /*1*/ /*fake_override*/ var modalExclusionType: java.awt.Dialog.ModalExclusionType! + invisible_fake final override /*1*/ /*fake_override*/ var mouseListener: java.awt.event.MouseListener! + invisible_fake final override /*1*/ /*fake_override*/ var mouseMotionListener: java.awt.event.MouseMotionListener! + invisible_fake final override /*1*/ /*fake_override*/ var mouseWheelListener: java.awt.event.MouseWheelListener! + invisible_fake final override /*1*/ /*fake_override*/ var name: kotlin.String! + invisible_fake final override /*1*/ /*fake_override*/ var nameExplicitlySet: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var newEventsOnly: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var numOfHWComponents: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var numOfLWComponents: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var objectLock: kotlin.Any! + invisible_fake final override /*1*/ /*fake_override*/ var opacity: kotlin.Float + invisible_fake final override /*1*/ /*fake_override*/ var ownedWindowList: java.util.Vector!>! + invisible_fake final override /*1*/ /*fake_override*/ var ownedWindows: java.util.Vector<(raw) kotlin.Any!>! + invisible_fake final override /*1*/ /*fake_override*/ var parent: java.awt.Container! + invisible_fake final override /*1*/ /*fake_override*/ var peer: java.awt.peer.ComponentPeer! + invisible_fake final override /*1*/ /*fake_override*/ var peerFont: java.awt.Font! + invisible_fake final override /*1*/ /*fake_override*/ var popups: java.util.Vector<(raw) kotlin.Any!>! + invisible_fake final override /*1*/ /*fake_override*/ var prefSize: java.awt.Dimension! + invisible_fake final override /*1*/ /*fake_override*/ var prefSizeSet: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var preserveBackgroundColor: java.awt.Color! + invisible_fake final override /*1*/ /*fake_override*/ var printing: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var printingThreads: kotlin.collections.(Mutable)Set<(raw) kotlin.Any?>! + invisible_fake final override /*1*/ /*fake_override*/ var resizable: kotlin.Boolean + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var rootPane: javax.swing.JRootPane! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var rootPaneCheckingEnabled: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var securityWarningAlignmentX: kotlin.Float + invisible_fake final override /*1*/ /*fake_override*/ var securityWarningAlignmentY: kotlin.Float + invisible_fake final override /*1*/ /*fake_override*/ var securityWarningHeight: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var securityWarningPointX: kotlin.Double + invisible_fake final override /*1*/ /*fake_override*/ var securityWarningPointY: kotlin.Double + invisible_fake final override /*1*/ /*fake_override*/ var securityWarningWidth: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var shape: java.awt.Shape! + invisible_fake final override /*1*/ /*fake_override*/ var showWithParent: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var state: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var syncLWRequests: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var temporaryLostComponent: java.awt.Component! + invisible_fake final override /*1*/ /*fake_override*/ var title: kotlin.String! + invisible_fake final override /*1*/ /*fake_override*/ var transferHandler: javax.swing.TransferHandler! + invisible_fake final override /*1*/ /*fake_override*/ var type: java.awt.Window.Type! + invisible_fake final override /*1*/ /*fake_override*/ var undecorated: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var valid: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var visible: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var warningString: kotlin.String! + invisible_fake final override /*1*/ /*fake_override*/ var weakThis: java.lang.ref.WeakReference! + invisible_fake final override /*1*/ /*fake_override*/ var width: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var windowClosingException: java.lang.RuntimeException! + invisible_fake final override /*1*/ /*fake_override*/ var windowFocusListener: java.awt.event.WindowFocusListener! + invisible_fake final override /*1*/ /*fake_override*/ var windowListener: java.awt.event.WindowListener! + invisible_fake final override /*1*/ /*fake_override*/ var windowSerializedDataVersion: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var windowStateListener: java.awt.event.WindowStateListener! + invisible_fake final override /*1*/ /*fake_override*/ var x: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var y: kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun action(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Any!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: java.awt.Component!): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Any!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Any!, /*2*/ p2: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Int): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: java.awt.PopupMenu!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ p0: kotlin.String!, /*1*/ p1: java.awt.Component!): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun addComponentListener(/*0*/ p0: java.awt.event.ComponentListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addContainerListener(/*0*/ p0: java.awt.event.ContainerListener!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun addDelicately(/*0*/ p0: java.awt.Component!, /*1*/ p1: java.awt.Container!, /*2*/ p2: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addFocusListener(/*0*/ p0: java.awt.event.FocusListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addHierarchyBoundsListener(/*0*/ p0: java.awt.event.HierarchyBoundsListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addHierarchyListener(/*0*/ p0: java.awt.event.HierarchyListener!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun addImpl(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Any!, /*2*/ p2: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addInputMethodListener(/*0*/ p0: java.awt.event.InputMethodListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addKeyListener(/*0*/ p0: java.awt.event.KeyListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addMouseListener(/*0*/ p0: java.awt.event.MouseListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addMouseMotionListener(/*0*/ p0: java.awt.event.MouseMotionListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addMouseWheelListener(/*0*/ p0: java.awt.event.MouseWheelListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addNotify(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun addOwnedWindow(/*0*/ p0: java.lang.ref.WeakReference<(raw) kotlin.Any!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addPropertyChangeListener(/*0*/ p0: java.beans.PropertyChangeListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addPropertyChangeListener(/*0*/ p0: kotlin.String!, /*1*/ p1: java.beans.PropertyChangeListener!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun addToWindowList(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addWindowFocusListener(/*0*/ p0: java.awt.event.WindowFocusListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addWindowListener(/*0*/ p0: java.awt.event.WindowListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addWindowStateListener(/*0*/ p0: java.awt.event.WindowStateListener!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun adjustDecendantsOnParent(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun adjustDescendants(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun adjustListeningChildren(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun adjustListeningChildrenOnParent(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun applyComponentOrientation(/*0*/ p0: java.awt.ComponentOrientation!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun applyCompoundShape(/*0*/ p0: sun.java2d.pipe.Region!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun applyCurrentShape(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun applyCurrentShapeBelowMe(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun applyResourceBundle(/*0*/ p0: java.util.ResourceBundle!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun applyResourceBundle(/*0*/ p0: kotlin.String!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun areBoundsValid(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun areFocusTraversalKeysSet(/*0*/ p0: kotlin.Int): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun areInputMethodsEnabled(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun autoProcessMouseWheel(/*0*/ p0: java.awt.event.MouseWheelEvent!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun bounds(): java.awt.Rectangle! + invisible_fake open override /*1*/ /*fake_override*/ fun calculateCurrentShape(): sun.java2d.pipe.Region! + invisible_fake open override /*1*/ /*fake_override*/ fun calculateSecurityWarningPosition(/*0*/ p0: kotlin.Double, /*1*/ p1: kotlin.Double, /*2*/ p2: kotlin.Double, /*3*/ p3: kotlin.Double): java.awt.geom.Point2D! + invisible_fake final override /*1*/ /*fake_override*/ fun canBeFocusOwner(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun canBeFocusOwnerRecursively(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun canContainFocusOwner(/*0*/ p0: java.awt.Component!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun checkAddToSelf(/*0*/ p0: java.awt.Component!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun checkAdding(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun checkCoalescing(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun checkGD(/*0*/ p0: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun checkImage(/*0*/ p0: java.awt.Image!, /*1*/ p1: java.awt.image.ImageObserver!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun checkImage(/*0*/ p0: java.awt.Image!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: java.awt.image.ImageObserver!): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun checkNotAWindow(/*0*/ p0: java.awt.Component!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun checkTreeLock(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun checkWindowClosingException(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun clearCurrentFocusCycleRootOnHide(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun clearMostRecentFocusOwnerOnHide(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun closeSplashScreen(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun coalesceEvents(/*0*/ p0: java.awt.AWTEvent!, /*1*/ p1: java.awt.AWTEvent!): java.awt.AWTEvent! + invisible_fake open override /*1*/ /*fake_override*/ fun connectOwnedWindow(/*0*/ p0: java.awt.Window!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun constructComponentName(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ p0: java.awt.Point!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun containsFocus(): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun countComponents(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun countHierarchyMembers(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun createBufferStrategy(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun createBufferStrategy(/*0*/ p0: kotlin.Int, /*1*/ p1: java.awt.BufferCapabilities!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun createChildHierarchyEvents(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Long, /*2*/ p2: kotlin.Boolean): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun createHierarchyEvents(/*0*/ p0: kotlin.Int, /*1*/ p1: java.awt.Component!, /*2*/ p2: java.awt.Container!, /*3*/ p3: kotlin.Long, /*4*/ p4: kotlin.Boolean): kotlin.Int + public open override /*1*/ /*fake_override*/ fun createImage(/*0*/ p0: java.awt.image.ImageProducer!): java.awt.Image! + public open override /*1*/ /*fake_override*/ fun createImage(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): java.awt.Image! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun createRootPane(): javax.swing.JRootPane! + public open override /*1*/ /*fake_override*/ fun createVolatileImage(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): java.awt.image.VolatileImage! + public open override /*1*/ /*fake_override*/ fun createVolatileImage(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: java.awt.ImageCapabilities!): java.awt.image.VolatileImage! + invisible_fake final override /*1*/ /*fake_override*/ fun decreaseComponentCount(/*0*/ p0: java.awt.Component!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun deliverEvent(/*0*/ p0: java.awt.Event!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun deliverMouseWheelToAncestor(/*0*/ p0: java.awt.event.MouseWheelEvent!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun deserializeResources(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun disable(): kotlin.Unit + protected/*protected and package*/ final override /*1*/ /*fake_override*/ fun disableEvents(/*0*/ p0: kotlin.Long): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun dispatchEvent(/*0*/ p0: java.awt.AWTEvent!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun dispatchEventImpl(/*0*/ p0: java.awt.AWTEvent!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun dispatchEventToSelf(/*0*/ p0: java.awt.AWTEvent!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun dispatchMouseWheelToAncestor(/*0*/ p0: java.awt.event.MouseWheelEvent!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun dispose(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun disposeImpl(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun doDispose(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun doLayout(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun doSwingSerialization(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun enable(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun enable(/*0*/ p0: kotlin.Boolean): kotlin.Unit + protected/*protected and package*/ final override /*1*/ /*fake_override*/ fun enableEvents(/*0*/ p0: kotlin.Long): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun enableInputMethods(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun eventEnabled(/*0*/ p0: java.awt.AWTEvent!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun eventTypeEnabled(/*0*/ p0: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun findComponentAt(/*0*/ p0: java.awt.Point!): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun findComponentAt(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): java.awt.Component! + invisible_fake final override /*1*/ /*fake_override*/ fun findComponentAt(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Boolean): java.awt.Component! + invisible_fake final override /*1*/ /*fake_override*/ fun findComponentAtImpl(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Boolean): java.awt.Component! + invisible_fake open override /*1*/ /*fake_override*/ fun findTraversalRoot(): java.awt.Container! + invisible_fake open override /*1*/ /*fake_override*/ fun findUnderMouseInWindow(/*0*/ p0: java.awt.PointerInfo!): java.awt.Component! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Any!, /*2*/ p2: kotlin.Any!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Boolean, /*2*/ p2: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Byte, /*2*/ p2: kotlin.Byte): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Char, /*2*/ p2: kotlin.Char): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Double, /*2*/ p2: kotlin.Double): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Float, /*2*/ p2: kotlin.Float): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Long, /*2*/ p2: kotlin.Long): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun firePropertyChange(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.Short, /*2*/ p2: kotlin.Short): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun frameInit(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun getAccessControlContext(): java.security.AccessControlContext! + invisible_fake open override /*1*/ /*fake_override*/ fun getAccessibleAt(/*0*/ p0: java.awt.Point!): javax.accessibility.Accessible! + invisible_fake open override /*1*/ /*fake_override*/ fun getAccessibleChild(/*0*/ p0: kotlin.Int): javax.accessibility.Accessible! + invisible_fake open override /*1*/ /*fake_override*/ fun getAccessibleChildrenCount(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getAccessibleContext(): javax.accessibility.AccessibleContext! + invisible_fake open override /*1*/ /*fake_override*/ fun getAccessibleIndexInParent(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun getAccessibleStateSet(): javax.accessibility.AccessibleStateSet! + public open override /*1*/ /*fake_override*/ fun getAlignmentX(): kotlin.Float + public open override /*1*/ /*fake_override*/ fun getAlignmentY(): kotlin.Float + invisible_fake open override /*1*/ /*fake_override*/ fun getAppliedShape(): sun.java2d.pipe.Region! + invisible_fake open override /*1*/ /*fake_override*/ fun getBackBuffer(): java.awt.Image! + public open override /*1*/ /*fake_override*/ fun getBackground(): java.awt.Color! + public open override /*1*/ /*fake_override*/ fun getBaseline(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getBaselineResizeBehavior(): java.awt.Component.BaselineResizeBehavior! + invisible_fake open override /*1*/ /*fake_override*/ fun getBottommostComponentIndex(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getBounds(): java.awt.Rectangle! + public open override /*1*/ /*fake_override*/ fun getBounds(/*0*/ p0: java.awt.Rectangle!): java.awt.Rectangle! + invisible_fake open override /*1*/ /*fake_override*/ fun getBoundsOp(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getBufferStrategy(): java.awt.image.BufferStrategy! + public open override /*1*/ /*fake_override*/ fun getColorModel(): java.awt.image.ColorModel! + public open override /*1*/ /*fake_override*/ fun getComponent(/*0*/ p0: kotlin.Int): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getComponentAt(/*0*/ p0: java.awt.Point!): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getComponentAt(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getComponentCount(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getComponentListeners(): kotlin.Array<(out) java.awt.event.ComponentListener!>! + public open override /*1*/ /*fake_override*/ fun getComponentOrientation(): java.awt.ComponentOrientation! + public open override /*1*/ /*fake_override*/ fun getComponentZOrder(/*0*/ p0: java.awt.Component!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getComponents(): kotlin.Array<(out) java.awt.Component!>! + invisible_fake open override /*1*/ /*fake_override*/ fun getComponentsSync(): kotlin.Array<(out) java.awt.Component!>! + invisible_fake final override /*1*/ /*fake_override*/ fun getComponents_NoClientCode(): kotlin.Array<(out) java.awt.Component!>! + invisible_fake final override /*1*/ /*fake_override*/ fun getContainer(): java.awt.Container! + public open override /*1*/ /*fake_override*/ fun getContainerListeners(): kotlin.Array<(out) java.awt.event.ContainerListener!>! + invisible_fake open override /*1*/ /*fake_override*/ fun getContainingWindow(): java.awt.Window! + public open override /*1*/ /*fake_override*/ fun getContentPane(): java.awt.Container! + public open override /*1*/ /*fake_override*/ fun getCursor(): java.awt.Cursor! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getCursorType(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun getCursor_NoClientCode(): java.awt.Cursor! + public open override /*1*/ /*fake_override*/ fun getDefaultCloseOperation(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun getDocumentRoot(): java.awt.Window! + public open override /*1*/ /*fake_override*/ fun getDropTarget(): java.awt.dnd.DropTarget! + invisible_fake open override /*1*/ /*fake_override*/ fun getDropTargetEventTarget(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Boolean): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getExtendedState(): kotlin.Int + public final override /*1*/ /*fake_override*/ fun getFocusCycleRootAncestor(): java.awt.Container! + public open override /*1*/ /*fake_override*/ fun getFocusListeners(): kotlin.Array<(out) java.awt.event.FocusListener!>! + public open override /*1*/ /*fake_override*/ fun getFocusOwner(): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getFocusTraversalKeys(/*0*/ p0: kotlin.Int): kotlin.collections.(Mutable)Set! + public open override /*1*/ /*fake_override*/ fun getFocusTraversalKeysEnabled(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun getFocusTraversalKeys_NoIDCheck(/*0*/ p0: kotlin.Int): kotlin.collections.(Mutable)Set<(raw) kotlin.Any?>! + public open override /*1*/ /*fake_override*/ fun getFocusTraversalPolicy(): java.awt.FocusTraversalPolicy! + public open override /*1*/ /*fake_override*/ fun getFocusableWindowState(): kotlin.Boolean + @java.beans.Transient public open override /*1*/ /*fake_override*/ fun getFont(): java.awt.Font! + public open override /*1*/ /*fake_override*/ fun getFontMetrics(/*0*/ p0: java.awt.Font!): java.awt.FontMetrics! + invisible_fake final override /*1*/ /*fake_override*/ fun getFont_NoClientCode(): java.awt.Font! + @java.beans.Transient public open override /*1*/ /*fake_override*/ fun getForeground(): java.awt.Color! + public open override /*1*/ /*fake_override*/ fun getGlassPane(): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getGraphics(): java.awt.Graphics! + public open override /*1*/ /*fake_override*/ fun getGraphicsConfiguration(): java.awt.GraphicsConfiguration! + invisible_fake final override /*1*/ /*fake_override*/ fun getGraphicsConfiguration_NoClientCode(): java.awt.GraphicsConfiguration! + invisible_fake final override /*1*/ /*fake_override*/ fun getGraphics_NoClientCode(): java.awt.Graphics! + invisible_fake final override /*1*/ /*fake_override*/ fun getHWPeerAboveMe(): java.awt.peer.ComponentPeer! + invisible_fake open override /*1*/ /*fake_override*/ fun getHeavyweightContainer(): java.awt.Container! + public open override /*1*/ /*fake_override*/ fun getHeight(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getHierarchyBoundsListeners(): kotlin.Array<(out) java.awt.event.HierarchyBoundsListener!>! + public open override /*1*/ /*fake_override*/ fun getHierarchyListeners(): kotlin.Array<(out) java.awt.event.HierarchyListener!>! + public open override /*1*/ /*fake_override*/ fun getIconImage(): java.awt.Image! + public open override /*1*/ /*fake_override*/ fun getIconImages(): kotlin.collections.(Mutable)List! + public open override /*1*/ /*fake_override*/ fun getIgnoreRepaint(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun getInputContext(): java.awt.im.InputContext! + public open override /*1*/ /*fake_override*/ fun getInputMethodListeners(): kotlin.Array<(out) java.awt.event.InputMethodListener!>! + public open override /*1*/ /*fake_override*/ fun getInputMethodRequests(): java.awt.im.InputMethodRequests! + public open override /*1*/ /*fake_override*/ fun getInsets(): java.awt.Insets! + invisible_fake open override /*1*/ /*fake_override*/ fun getInsets_NoClientCode(): java.awt.Insets! + public open override /*1*/ /*fake_override*/ fun getJMenuBar(): javax.swing.JMenuBar! + public open override /*1*/ /*fake_override*/ fun getKeyListeners(): kotlin.Array<(out) java.awt.event.KeyListener!>! + public open override /*1*/ /*fake_override*/ fun getLayeredPane(): javax.swing.JLayeredPane! + public open override /*1*/ /*fake_override*/ fun getLayout(): java.awt.LayoutManager! + public open override /*1*/ /*fake_override*/ fun getListeners(/*0*/ p0: java.lang.Class!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun getListenersCount(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Boolean): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getLocale(): java.util.Locale! + public open override /*1*/ /*fake_override*/ fun getLocation(): java.awt.Point! + public open override /*1*/ /*fake_override*/ fun getLocation(/*0*/ p0: java.awt.Point!): java.awt.Point! + public open override /*1*/ /*fake_override*/ fun getLocationOnScreen(): java.awt.Point! + invisible_fake final override /*1*/ /*fake_override*/ fun getLocationOnScreen_NoTreeLock(): java.awt.Point! + invisible_fake final override /*1*/ /*fake_override*/ fun getLocationOnWindow(): java.awt.Point! + public open override /*1*/ /*fake_override*/ fun getMaximizedBounds(): java.awt.Rectangle! + public open override /*1*/ /*fake_override*/ fun getMaximumSize(): java.awt.Dimension! + public open override /*1*/ /*fake_override*/ fun getMenuBar(): java.awt.MenuBar! + public open override /*1*/ /*fake_override*/ fun getMinimumSize(): java.awt.Dimension! + invisible_fake open override /*1*/ /*fake_override*/ fun getModalBlocker(): java.awt.Dialog! + public open override /*1*/ /*fake_override*/ fun getModalExclusionType(): java.awt.Dialog.ModalExclusionType! + public open override /*1*/ /*fake_override*/ fun getMostRecentFocusOwner(): java.awt.Component! + invisible_fake open override /*1*/ /*fake_override*/ fun getMouseEventTarget(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Boolean): java.awt.Component! + invisible_fake open override /*1*/ /*fake_override*/ fun getMouseEventTarget(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Boolean, /*3*/ p3: java.awt.Container.EventTargetFilter!, /*4*/ p4: kotlin.Boolean): java.awt.Component! + invisible_fake open override /*1*/ /*fake_override*/ fun getMouseEventTargetImpl(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Boolean, /*3*/ p3: java.awt.Container.EventTargetFilter!, /*4*/ p4: kotlin.Boolean, /*5*/ p5: kotlin.Boolean): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getMouseListeners(): kotlin.Array<(out) java.awt.event.MouseListener!>! + public open override /*1*/ /*fake_override*/ fun getMouseMotionListeners(): kotlin.Array<(out) java.awt.event.MouseMotionListener!>! + public open override /*1*/ /*fake_override*/ fun getMousePosition(): java.awt.Point! + public open override /*1*/ /*fake_override*/ fun getMousePosition(/*0*/ p0: kotlin.Boolean): java.awt.Point! + public open override /*1*/ /*fake_override*/ fun getMouseWheelListeners(): kotlin.Array<(out) java.awt.event.MouseWheelListener!>! + public open override /*1*/ /*fake_override*/ fun getName(): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun getNativeContainer(): java.awt.Container! + invisible_fake final override /*1*/ /*fake_override*/ fun getNextFocusCandidate(): java.awt.Component! + invisible_fake final override /*1*/ /*fake_override*/ fun getNormalShape(): sun.java2d.pipe.Region! + invisible_fake open override /*1*/ /*fake_override*/ fun getObjectLock(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun getOpacity(): kotlin.Float + invisible_fake final override /*1*/ /*fake_override*/ fun getOpaqueShape(): sun.java2d.pipe.Region! + public open override /*1*/ /*fake_override*/ fun getOwnedWindows(): kotlin.Array<(out) java.awt.Window!>! + invisible_fake final override /*1*/ /*fake_override*/ fun getOwnedWindows_NoClientCode(): kotlin.Array<(out) java.awt.Window!>! + public open override /*1*/ /*fake_override*/ fun getOwner(): java.awt.Window! + invisible_fake final override /*1*/ /*fake_override*/ fun getOwner_NoClientCode(): java.awt.Window! + public open override /*1*/ /*fake_override*/ fun getParent(): java.awt.Container! + invisible_fake final override /*1*/ /*fake_override*/ fun getParent_NoClientCode(): java.awt.Container! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getPeer(): java.awt.peer.ComponentPeer! + public open override /*1*/ /*fake_override*/ fun getPreferredSize(): java.awt.Dimension! + public open override /*1*/ /*fake_override*/ fun getPropertyChangeListeners(): kotlin.Array<(out) java.beans.PropertyChangeListener!>! + public open override /*1*/ /*fake_override*/ fun getPropertyChangeListeners(/*0*/ p0: kotlin.String!): kotlin.Array<(out) java.beans.PropertyChangeListener!>! + public open override /*1*/ /*fake_override*/ fun getRootPane(): javax.swing.JRootPane! + public open override /*1*/ /*fake_override*/ fun getShape(): java.awt.Shape! + invisible_fake final override /*1*/ /*fake_override*/ fun getSiblingIndexAbove(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun getSiblingIndexBelow(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getSize(): java.awt.Dimension! + public open override /*1*/ /*fake_override*/ fun getSize(/*0*/ p0: java.awt.Dimension!): java.awt.Dimension! + public open override /*1*/ /*fake_override*/ fun getState(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun getTemporaryLostComponent(): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun getTitle(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getToolkit(): java.awt.Toolkit! + invisible_fake final override /*1*/ /*fake_override*/ fun getToolkitImpl(): java.awt.Toolkit! + invisible_fake open override /*1*/ /*fake_override*/ fun getTopmostComponentIndex(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getTransferHandler(): javax.swing.TransferHandler! + invisible_fake final override /*1*/ /*fake_override*/ fun getTraversalRoot(): java.awt.Container! + public final override /*1*/ /*fake_override*/ fun getTreeLock(): kotlin.Any! + public open override /*1*/ /*fake_override*/ fun getType(): java.awt.Window.Type! + public final override /*1*/ /*fake_override*/ fun getWarningString(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getWidth(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getWindowFocusListeners(): kotlin.Array<(out) java.awt.event.WindowFocusListener!>! + public open override /*1*/ /*fake_override*/ fun getWindowListeners(): kotlin.Array<(out) java.awt.event.WindowListener!>! + public open override /*1*/ /*fake_override*/ fun getWindowStateListeners(): kotlin.Array<(out) java.awt.event.WindowStateListener!>! + public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getY(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun gotFocus(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Any!): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun handleEvent(/*0*/ p0: java.awt.Event!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hasFocus(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun hasHeavyweightDescendants(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun hasLightweightDescendants(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun hide(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun imageUpdate(/*0*/ p0: java.awt.Image!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int, /*4*/ p4: kotlin.Int, /*5*/ p5: kotlin.Int): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun increaseComponentCount(/*0*/ p0: java.awt.Component!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun init(/*0*/ p0: java.awt.GraphicsConfiguration!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun init(/*0*/ p0: kotlin.String!, /*1*/ p1: java.awt.GraphicsConfiguration!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun initDeserializedWindow(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun initGC(/*0*/ p0: java.awt.GraphicsConfiguration!): java.awt.GraphicsConfiguration! + invisible_fake open override /*1*/ /*fake_override*/ fun initializeFocusTraversalKeys(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun insets(): java.awt.Insets! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun inside(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun invalidate(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun invalidateIfValid(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun invalidateParent(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun invalidateTree(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun isActive(): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun isAlwaysOnTop(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isAlwaysOnTopSupported(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isAncestorOf(/*0*/ p0: java.awt.Component!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isAutoFocusTransferOnDisposal(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isAutoRequestFocus(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isBackgroundSet(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isCoalescingEnabled(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isCursorSet(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isDisplayable(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isDisposing(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isDoubleBuffered(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isEnabled(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isEnabledImpl(): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun isFocusCycleRoot(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isFocusCycleRoot(/*0*/ p0: java.awt.Container!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isFocusOwner(): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun isFocusTraversable(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isFocusTraversableOverridden(): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun isFocusTraversalPolicyProvider(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isFocusTraversalPolicySet(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isFocusable(): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun isFocusableWindow(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isFocused(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isFontSet(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isForegroundSet(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isFrameStateSupported(/*0*/ p0: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isLightweight(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isLocationByPlatform(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isMaximumSizeSet(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isMinimumSizeSet(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isMixingNeeded(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isModalBlocked(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isModalExcluded(/*0*/ p0: java.awt.Dialog.ModalExclusionType!): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isNonOpaqueForMixing(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isOpaque(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isParentOf(/*0*/ p0: java.awt.Component!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isPreferredSizeSet(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isRecursivelyVisible(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isRecursivelyVisibleUpToHeavyweightContainer(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isRequestFocusAccepted(/*0*/ p0: kotlin.Boolean, /*1*/ p1: kotlin.Boolean, /*2*/ p2: sun.awt.CausedFocusEvent.Cause!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isResizable(): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun isRootPaneCheckingEnabled(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isSameOrAncestorOf(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isShowing(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isUndecorated(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isValid(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isValidateRoot(): kotlin.Boolean + @java.beans.Transient public open override /*1*/ /*fake_override*/ fun isVisible(): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun isVisible_NoClientCode(): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun keyDown(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun keyUp(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun layout(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun lightweightPaint(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun lightweightPrint(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun list(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun list(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun list(/*0*/ p0: java.io.PrintStream!, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun list(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun list(/*0*/ p0: java.io.PrintWriter!, /*1*/ p1: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun locate(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): java.awt.Component! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun location(): java.awt.Point! + invisible_fake open override /*1*/ /*fake_override*/ fun location_NoClientCode(): java.awt.Point! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun lostFocus(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Any!): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun minimumSize(): java.awt.Dimension! + invisible_fake open override /*1*/ /*fake_override*/ fun mixOnHiding(/*0*/ p0: kotlin.Boolean): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun mixOnReshaping(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun mixOnShowing(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun mixOnValidating(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun mixOnZOrderChanging(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun mouseDown(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun mouseDrag(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun mouseEnter(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun mouseExit(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun mouseMove(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun mouseUp(/*0*/ p0: java.awt.Event!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun move(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun nextFocus(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun notifyNewBounds(/*0*/ p0: kotlin.Boolean, /*1*/ p1: kotlin.Boolean): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun numListening(/*0*/ p0: kotlin.Long): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun ownedInit(/*0*/ p0: java.awt.Window!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun pack(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun paint(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun paintAll(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun paintComponents(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun paintHeavyweightComponents(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun paramString(): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun pointRelativeToComponent(/*0*/ p0: java.awt.Point!): java.awt.Point! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun postEvent(/*0*/ p0: java.awt.Event!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun postProcessKeyEvent(/*0*/ p0: java.awt.event.KeyEvent!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun postWindowEvent(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun postsOldMouseEvents(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun preProcessKeyEvent(/*0*/ p0: java.awt.event.KeyEvent!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun preferredSize(): java.awt.Dimension! + public open override /*1*/ /*fake_override*/ fun prepareImage(/*0*/ p0: java.awt.Image!, /*1*/ p1: java.awt.image.ImageObserver!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun prepareImage(/*0*/ p0: java.awt.Image!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: java.awt.image.ImageObserver!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun print(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printAll(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printComponents(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun printHeavyweightComponents(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processComponentEvent(/*0*/ p0: java.awt.event.ComponentEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processContainerEvent(/*0*/ p0: java.awt.event.ContainerEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processEvent(/*0*/ p0: java.awt.AWTEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processFocusEvent(/*0*/ p0: java.awt.event.FocusEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processHierarchyBoundsEvent(/*0*/ p0: java.awt.event.HierarchyEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processHierarchyEvent(/*0*/ p0: java.awt.event.HierarchyEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processInputMethodEvent(/*0*/ p0: java.awt.event.InputMethodEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processKeyEvent(/*0*/ p0: java.awt.event.KeyEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processMouseEvent(/*0*/ p0: java.awt.event.MouseEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processMouseMotionEvent(/*0*/ p0: java.awt.event.MouseEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processMouseWheelEvent(/*0*/ p0: java.awt.event.MouseWheelEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processWindowEvent(/*0*/ p0: java.awt.event.WindowEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processWindowFocusEvent(/*0*/ p0: java.awt.event.WindowEvent!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun processWindowStateEvent(/*0*/ p0: java.awt.event.WindowEvent!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun proxyEnableEvents(/*0*/ p0: kotlin.Long): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun recursiveApplyCurrentShape(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun recursiveApplyCurrentShape(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun recursiveApplyCurrentShape(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun recursiveHideHeavyweightChildren(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun recursiveRelocateHeavyweightChildren(/*0*/ p0: java.awt.Point!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun recursiveShowHeavyweightChildren(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun recursiveSubtractAndApplyShape(/*0*/ p0: sun.java2d.pipe.Region!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun recursiveSubtractAndApplyShape(/*0*/ p0: sun.java2d.pipe.Region!, /*1*/ p1: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun recursiveSubtractAndApplyShape(/*0*/ p0: sun.java2d.pipe.Region!, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun relocateComponent(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0: java.awt.Component!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0: java.awt.MenuComponent!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeAll(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeComponentListener(/*0*/ p0: java.awt.event.ComponentListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeContainerListener(/*0*/ p0: java.awt.event.ContainerListener!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun removeDelicately(/*0*/ p0: java.awt.Component!, /*1*/ p1: java.awt.Container!, /*2*/ p2: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeFocusListener(/*0*/ p0: java.awt.event.FocusListener!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun removeFromWindowList(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeHierarchyBoundsListener(/*0*/ p0: java.awt.event.HierarchyBoundsListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeHierarchyListener(/*0*/ p0: java.awt.event.HierarchyListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeInputMethodListener(/*0*/ p0: java.awt.event.InputMethodListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeKeyListener(/*0*/ p0: java.awt.event.KeyListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeMouseListener(/*0*/ p0: java.awt.event.MouseListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeMouseMotionListener(/*0*/ p0: java.awt.event.MouseMotionListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeMouseWheelListener(/*0*/ p0: java.awt.event.MouseWheelListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeNotify(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun removeOwnedWindow(/*0*/ p0: java.lang.ref.WeakReference<(raw) kotlin.Any!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removePropertyChangeListener(/*0*/ p0: java.beans.PropertyChangeListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removePropertyChangeListener(/*0*/ p0: kotlin.String!, /*1*/ p1: java.beans.PropertyChangeListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeWindowFocusListener(/*0*/ p0: java.awt.event.WindowFocusListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeWindowListener(/*0*/ p0: java.awt.event.WindowListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun removeWindowStateListener(/*0*/ p0: java.awt.event.WindowStateListener!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun repaint(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun repaint(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun repaint(/*0*/ p0: kotlin.Long): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun repaint(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int, /*4*/ p4: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun repaintParentIfNeeded(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun reparentChild(/*0*/ p0: java.awt.Component!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun reparentTraverse(/*0*/ p0: java.awt.peer.ContainerPeer!, /*1*/ p1: java.awt.Container!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun requestFocus(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun requestFocus(/*0*/ p0: kotlin.Boolean): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun requestFocus(/*0*/ p0: kotlin.Boolean, /*1*/ p1: sun.awt.CausedFocusEvent.Cause!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun requestFocus(/*0*/ p0: sun.awt.CausedFocusEvent.Cause!): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun requestFocusHelper(/*0*/ p0: kotlin.Boolean, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ fun requestFocusHelper(/*0*/ p0: kotlin.Boolean, /*1*/ p1: kotlin.Boolean, /*2*/ p2: sun.awt.CausedFocusEvent.Cause!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun requestFocusInWindow(): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun requestFocusInWindow(/*0*/ p0: kotlin.Boolean): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun requestFocusInWindow(/*0*/ p0: kotlin.Boolean, /*1*/ p1: sun.awt.CausedFocusEvent.Cause!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun requestFocusInWindow(/*0*/ p0: sun.awt.CausedFocusEvent.Cause!): kotlin.Boolean + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun reshape(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun reshapeNativePeer(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int, /*4*/ p4: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun resize(/*0*/ p0: java.awt.Dimension!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun resize(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun revalidate(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun revalidateSynchronously(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun setAlwaysOnTop(/*0*/ p0: kotlin.Boolean): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setAutoFocusTransferOnDisposal(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setAutoRequestFocus(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setBackground(/*0*/ p0: java.awt.Color!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setBounds(/*0*/ p0: java.awt.Rectangle!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setBounds(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setBoundsOp(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setClientSize(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setComponentOrientation(/*0*/ p0: java.awt.ComponentOrientation!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setComponentZOrder(/*0*/ p0: java.awt.Component!, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setContentPane(/*0*/ p0: java.awt.Container!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setCursor(/*0*/ p0: java.awt.Cursor!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setCursor(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setDefaultCloseOperation(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setDropTarget(/*0*/ p0: java.awt.dnd.DropTarget!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setEnabled(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setExtendedState(/*0*/ p0: kotlin.Int): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun setFocusCycleRoot(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setFocusTraversalKeys(/*0*/ p0: kotlin.Int, /*1*/ p1: (kotlin.collections.MutableSet..kotlin.collections.Set?)): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setFocusTraversalKeysEnabled(/*0*/ p0: kotlin.Boolean): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun setFocusTraversalKeys_NoIDCheck(/*0*/ p0: kotlin.Int, /*1*/ p1: (kotlin.collections.MutableSet..kotlin.collections.Set?)): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setFocusTraversalPolicy(/*0*/ p0: java.awt.FocusTraversalPolicy!): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun setFocusTraversalPolicyProvider(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setFocusable(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setFocusableWindowState(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setFont(/*0*/ p0: java.awt.Font!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setForeground(/*0*/ p0: java.awt.Color!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setGlassPane(/*0*/ p0: java.awt.Component!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setGraphicsConfiguration(/*0*/ p0: java.awt.GraphicsConfiguration!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setIconImage(/*0*/ p0: java.awt.Image!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setIconImages(/*0*/ p0: (kotlin.collections.MutableList..kotlin.collections.List?)): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setIgnoreRepaint(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setJMenuBar(/*0*/ p0: javax.swing.JMenuBar!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLayeredPane(/*0*/ p0: javax.swing.JLayeredPane!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLayout(/*0*/ p0: java.awt.LayoutManager!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLocale(/*0*/ p0: java.util.Locale!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLocation(/*0*/ p0: java.awt.Point!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLocation(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLocationByPlatform(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setLocationRelativeTo(/*0*/ p0: java.awt.Component!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setMaximizedBounds(/*0*/ p0: java.awt.Rectangle!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setMaximumSize(/*0*/ p0: java.awt.Dimension!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setMenuBar(/*0*/ p0: java.awt.MenuBar!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setMinimumSize(/*0*/ p0: java.awt.Dimension!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setModalBlocked(/*0*/ p0: java.awt.Dialog!, /*1*/ p1: kotlin.Boolean, /*2*/ p2: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setModalExclusionType(/*0*/ p0: java.awt.Dialog.ModalExclusionType!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setName(/*0*/ p0: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setOpacity(/*0*/ p0: kotlin.Float): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setPreferredSize(/*0*/ p0: java.awt.Dimension!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setResizable(/*0*/ p0: kotlin.Boolean): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun setRootPane(/*0*/ p0: javax.swing.JRootPane!): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun setRootPaneCheckingEnabled(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setShape(/*0*/ p0: java.awt.Shape!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setSize(/*0*/ p0: java.awt.Dimension!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setSize(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setState(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setTemporaryLostComponent(/*0*/ p0: java.awt.Component!): java.awt.Component! + public open override /*1*/ /*fake_override*/ fun setTitle(/*0*/ p0: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setTransferHandler(/*0*/ p0: javax.swing.TransferHandler!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setType(/*0*/ p0: java.awt.Window.Type!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setUndecorated(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setVisible(/*0*/ p0: kotlin.Boolean): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setWarningString(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun show(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun show(/*0*/ p0: kotlin.Boolean): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun size(): java.awt.Dimension! + invisible_fake open override /*1*/ /*fake_override*/ fun startLWModal(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun stopLWModal(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun subtractAndApplyShape(/*0*/ p0: sun.java2d.pipe.Region!): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun subtractAndApplyShapeBelowMe(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toBack(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun toBack_NoClientCode(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toFront(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun toFront_NoClientCode(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun transferFocus(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun transferFocus(/*0*/ p0: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun transferFocusBackward(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun transferFocusBackward(/*0*/ p0: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun transferFocusDownCycle(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun transferFocusUpCycle(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun update(/*0*/ p0: java.awt.Graphics!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun updateChildrenBlocking(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun updateCursorImmediately(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun updateGraphicsData(/*0*/ p0: java.awt.GraphicsConfiguration!): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun updateWindow(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun updateZOrder(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun validate(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun validateTree(): kotlin.Unit + invisible_fake final override /*1*/ /*fake_override*/ fun validateUnconditionally(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt index 707c5960b5d..f28e2025245 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test import javax.swing.JFrame diff --git a/compiler/testData/diagnostics/tests/regressions/kt498.javac.txt b/compiler/testData/diagnostics/tests/regressions/kt498.javac.txt new file mode 100644 index 00000000000..9c2c69eac96 --- /dev/null +++ b/compiler/testData/diagnostics/tests/regressions/kt498.javac.txt @@ -0,0 +1,22 @@ +package + +public fun T.getJavaClass(): java.lang.Class + +public final class IdUnavailableException : kotlin.Exception /* = java.lang.Exception */ { + public constructor IdUnavailableException() + public open override /*1*/ /*fake_override*/ val cause: kotlin.Throwable? + public open override /*1*/ /*fake_override*/ val message: kotlin.String? + public final override /*1*/ /*fake_override*/ fun addSuppressed(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun fillInStackTrace(): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun getLocalizedMessage(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public final override /*1*/ /*fake_override*/ fun getSuppressed(): kotlin.Array<(out) kotlin.Throwable!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun initCause(/*0*/ p0: kotlin.Throwable!): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun printStackTrace(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setStackTrace(/*0*/ p0: kotlin.Array<(out) java.lang.StackTraceElement!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt498.kt b/compiler/testData/diagnostics/tests/regressions/kt498.kt index d6eac9c2129..4df3c6fa476 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt498.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt498.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // KT-498 Very strange error in the type checker class IdUnavailableException() : Exception() {} diff --git a/compiler/testData/diagnostics/tests/regressions/kt588.javac.txt b/compiler/testData/diagnostics/tests/regressions/kt588.javac.txt new file mode 100644 index 00000000000..792c43cc77a --- /dev/null +++ b/compiler/testData/diagnostics/tests/regressions/kt588.javac.txt @@ -0,0 +1,80 @@ +package + +public final class Test : java.lang.Thread { + public constructor Test() + invisible_fake final override /*1*/ /*fake_override*/ var blocker: sun.nio.ch.Interruptible! + invisible_fake final override /*1*/ /*fake_override*/ val blockerLock: kotlin.Any! + invisible_fake final override /*1*/ /*fake_override*/ var contextClassLoader: java.lang.ClassLoader! + invisible_fake final override /*1*/ /*fake_override*/ var daemon: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var eetop: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var group: java.lang.ThreadGroup! + invisible_fake final override /*1*/ /*fake_override*/ var inheritableThreadLocals: java.lang.ThreadLocal.ThreadLocalMap! + invisible_fake final override /*1*/ /*fake_override*/ var inheritedAccessControlContext: java.security.AccessControlContext! + invisible_fake final override /*1*/ /*fake_override*/ var name: kotlin.CharArray! + invisible_fake final override /*1*/ /*fake_override*/ var nativeParkEventPointer: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var parkBlocker: kotlin.Any! + invisible_fake final override /*1*/ /*fake_override*/ var priority: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var single_step: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var stackSize: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var stillborn: kotlin.Boolean + invisible_fake final override /*1*/ /*fake_override*/ var target: java.lang.Runnable! + invisible_fake final override /*1*/ /*fake_override*/ var threadLocals: java.lang.ThreadLocal.ThreadLocalMap! + invisible_fake final override /*1*/ /*fake_override*/ var threadQ: java.lang.Thread! + invisible_fake final override /*1*/ /*fake_override*/ var threadStatus: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var tid: kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ var uncaughtExceptionHandler: java.lang.Thread.UncaughtExceptionHandler! + invisible_fake open override /*1*/ /*fake_override*/ fun blockedOn(/*0*/ p0: sun.nio.ch.Interruptible!): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun checkAccess(): kotlin.Unit + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun countStackFrames(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun destroy(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun dispatchUncaughtException(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun exit(): kotlin.Unit + @sun.reflect.CallerSensitive public open override /*1*/ /*fake_override*/ fun getContextClassLoader(): java.lang.ClassLoader! + public open override /*1*/ /*fake_override*/ fun getId(): kotlin.Long + public final override /*1*/ /*fake_override*/ fun getName(): kotlin.String! + public final override /*1*/ /*fake_override*/ fun getPriority(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public open override /*1*/ /*fake_override*/ fun getState(): java.lang.Thread.State! + public final override /*1*/ /*fake_override*/ fun getThreadGroup(): java.lang.ThreadGroup! + public open override /*1*/ /*fake_override*/ fun getUncaughtExceptionHandler(): java.lang.Thread.UncaughtExceptionHandler! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun init(/*0*/ p0: java.lang.ThreadGroup!, /*1*/ p1: java.lang.Runnable!, /*2*/ p2: kotlin.String!, /*3*/ p3: kotlin.Long): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun init(/*0*/ p0: java.lang.ThreadGroup!, /*1*/ p1: java.lang.Runnable!, /*2*/ p2: kotlin.String!, /*3*/ p3: kotlin.Long, /*4*/ p4: java.security.AccessControlContext!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun interrupt(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun interrupt0(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun isAlive(): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun isDaemon(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun isInterrupted(): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun isInterrupted(/*0*/ p0: kotlin.Boolean): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun join(): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun join(/*0*/ p0: kotlin.Long): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun join(/*0*/ p0: kotlin.Long, /*1*/ p1: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public final override /*1*/ /*fake_override*/ fun resume(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun resume0(): kotlin.Unit + public open override /*1*/ fun run(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setContextClassLoader(/*0*/ p0: java.lang.ClassLoader!): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun setDaemon(/*0*/ p0: kotlin.Boolean): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun setName(/*0*/ p0: kotlin.String!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setNativeName(/*0*/ p0: kotlin.String!): kotlin.Unit + public final override /*1*/ /*fake_override*/ fun setPriority(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun setPriority0(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setUncaughtExceptionHandler(/*0*/ p0: java.lang.Thread.UncaughtExceptionHandler!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun start(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun start0(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public final override /*1*/ /*fake_override*/ fun stop(): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public final override /*1*/ /*fake_override*/ fun stop(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun stop0(/*0*/ p0: kotlin.Any!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public final override /*1*/ /*fake_override*/ fun suspend(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun suspend0(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final fun init2(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt588.kt b/compiler/testData/diagnostics/tests/regressions/kt588.kt index 583b205e211..4f6637a9eb5 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt588.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt588.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // KT-588 Unresolved static method class Test() : Thread("Test") { diff --git a/compiler/testData/diagnostics/tests/regressions/kt6508.txt b/compiler/testData/diagnostics/tests/regressions/kt6508.txt index 4c4889588bf..d96e8ce9d37 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt6508.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt6508.txt @@ -1,3 +1,20 @@ package public fun kotlin.String.gah(/*0*/ view: foo.View?): kotlin.Unit + +package foo { + + public open class TextView : foo.View { + public constructor TextView() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class View { + public constructor View() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt index 93c32236baa..8414bfee2b6 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt @@ -1,6 +1,6 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER // FILE: J.java -import java.util.* +import java.util.*; public class J { public static > String foo(E1 e) { return ""; } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt index 57187527e90..8ceb7fe130c 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt @@ -1,6 +1,6 @@ // FILE: A.java public interface A { - public class A_ + public class A_ {} } // FILE: 1.kt @@ -24,4 +24,4 @@ class Y: B { companion object { val b: B_ = B_() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt index f9a240211ea..c8de65ef916 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt @@ -17,14 +17,14 @@ open class K : C(), I // FILE: D.java -public class D extends K, I { +public class D extends K implements I { static int c = 1; static void baz() {} } // FILE: E.java -public class E extends D, I { +public class E extends D implements I { static int a = 1; } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt index be26864b233..10b07d1924a 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt @@ -24,7 +24,7 @@ class C: B() { // FILE: X.java public class X extends B { static double foo() { - return 1.0 + return 1.0; } } @@ -33,4 +33,4 @@ class Y: X() { init { val a: Double = foo() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt1942.txt b/compiler/testData/diagnostics/tests/scopes/kt1942.txt index a487203b95b..96a12f5048f 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1942.txt +++ b/compiler/testData/diagnostics/tests/scopes/kt1942.txt @@ -1,5 +1,16 @@ package +package a { + + public open class C { + public constructor C() + public/*package*/ final var myValue: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + package d { public final class A : a.C { diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.txt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.txt index 9471f0589be..45e735c4791 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.txt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.txt @@ -11,3 +11,20 @@ package k1 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + +package p1 { + + public open class BaseClass { + public constructor BaseClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + protected/*protected and package*/ open inner class ProtSubClass { + public constructor ProtSubClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt index e434a606751..c799c4c1996 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt @@ -14,7 +14,7 @@ public class JavaClass { } // FILE: foo/JavaClassSamePackage.java -package foo +package foo; public class JavaClassSamePackage extends bar.JavaClass { protected static void bar2() {} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.txt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.txt index 006dbddeee0..7af1cacc4aa 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.txt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.txt @@ -1,5 +1,23 @@ package +package bar { + + public open class JavaClass { + public constructor JavaClass() + protected/*protected and package*/ final var field: kotlin.String! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected/*protected and package*/ open fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + protected/*protected static*/ final var CONST1: kotlin.String! + protected/*protected static*/ final var CONST2: kotlin.String! + protected/*protected static*/ open fun bar1(): kotlin.Unit + protected/*protected static*/ open fun bar2(): kotlin.Unit + } +} + package foo { public fun test(/*0*/ a: foo.KotlinClass, /*1*/ b: foo.KotlinClass2): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.txt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.txt index cf2d4596da7..b7228af207e 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.txt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.txt @@ -1,5 +1,16 @@ package +package module1 { + + public abstract class AbstractModule { + public constructor AbstractModule() + protected/*protected and package*/ open fun bind(/*0*/ clazz: java.lang.Class!): S! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + package module2 { public fun javaClass(): java.lang.Class diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.txt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.txt index 912922e2ac4..2b867043952 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.txt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.txt @@ -7,3 +7,15 @@ public final class B4 : abc.A { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package abc { + + public open class A { + protected/*protected and package*/ constructor A() + public constructor A(/*0*/ x: kotlin.Double) + protected/*protected and package*/ constructor A(/*0*/ x: kotlin.Int) + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.txt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.txt index 426f3c553b5..04ab5d702e2 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.txt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.txt @@ -21,3 +21,17 @@ public final class Data { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package abc { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getAbc(): kotlin.Int + public open fun getBar(): kotlin.String! + protected/*protected and package*/ open fun getFoo(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + protected/*protected and package*/ open fun setBar(/*0*/ x: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.txt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.txt index b0fe21a1f2d..003bedf3190 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.txt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.txt @@ -18,3 +18,14 @@ public final class Data { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package abc { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected/*protected and package*/ open fun foo(/*0*/ x: java.lang.Runnable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/scopes/visibility2.javac.txt b/compiler/testData/diagnostics/tests/scopes/visibility2.javac.txt new file mode 100644 index 00000000000..521bef665cd --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/visibility2.javac.txt @@ -0,0 +1,96 @@ +package + +package a { + private fun foo(): kotlin.Unit + public fun makeA(): a.A + + private open class A { + public constructor A() + public final fun bar(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + private object PO { + private constructor PO() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + public fun test(): kotlin.Unit + + public final class B : a.A { + public constructor B() + invisible_fake final override /*1*/ /*fake_override*/ fun bar(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public final class NewClass : java.util.ArrayList { + public constructor NewClass() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: java.lang.Integer): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: java.lang.Integer): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: java.lang.Integer): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): java.lang.Integer! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): java.lang.Integer + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: java.lang.Integer): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: java.lang.Integer): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: java.lang.Integer): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): java.lang.Integer + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: java.lang.Integer): java.lang.Integer + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit + } + + public final class Q { + public constructor Q() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final class W { + public constructor W() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/diagnostics/tests/scopes/visibility2.kt b/compiler/testData/diagnostics/tests/scopes/visibility2.kt index 62c31733a8d..ae14c01d8e2 100644 --- a/compiler/testData/diagnostics/tests/scopes/visibility2.kt +++ b/compiler/testData/diagnostics/tests/scopes/visibility2.kt @@ -1,5 +1,5 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE - +// JAVAC_EXPECTED_FILE //FILE:a.kt package a diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.javac.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.javac.txt new file mode 100644 index 00000000000..0f77ad98508 --- /dev/null +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.javac.txt @@ -0,0 +1,46 @@ +package + +public fun test(): kotlin.Unit +public fun test2(): kotlin.Unit +public fun test3(): kotlin.Unit +public fun test4(): kotlin.Unit +public fun test5(): kotlin.Unit +public fun test6(): kotlin.Unit + +public final class A : kotlin.Exception /* = java.lang.Exception */ { + public constructor A() + public open override /*1*/ /*fake_override*/ val cause: kotlin.Throwable? + public open override /*1*/ /*fake_override*/ val message: kotlin.String? + public final override /*1*/ /*fake_override*/ fun addSuppressed(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun fillInStackTrace(): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun getLocalizedMessage(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public final override /*1*/ /*fake_override*/ fun getSuppressed(): kotlin.Array<(out) kotlin.Throwable!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun initCause(/*0*/ p0: kotlin.Throwable!): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun printStackTrace(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setStackTrace(/*0*/ p0: kotlin.Array<(out) java.lang.StackTraceElement!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B : kotlin.Exception /* = java.lang.Exception */ { + public constructor B() + public open override /*1*/ /*fake_override*/ val cause: kotlin.Throwable? + public open override /*1*/ /*fake_override*/ val message: kotlin.String? + public final override /*1*/ /*fake_override*/ fun addSuppressed(/*0*/ p0: kotlin.Throwable!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun fillInStackTrace(): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun getLocalizedMessage(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun getStackTrace(): kotlin.Array<(out) java.lang.StackTraceElement!>! + public final override /*1*/ /*fake_override*/ fun getSuppressed(): kotlin.Array<(out) kotlin.Throwable!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun initCause(/*0*/ p0: kotlin.Throwable!): kotlin.Throwable! + public open override /*1*/ /*fake_override*/ fun printStackTrace(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun printStackTrace(/*0*/ p0: java.io.PrintWriter!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setStackTrace(/*0*/ p0: kotlin.Array<(out) java.lang.StackTraceElement!>!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt index 087c88b63f6..fd10410c755 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // See also KT-10735 fun test() { var a: Int? diff --git a/compiler/testData/diagnostics/tests/subtyping/kt-1457.javac.txt b/compiler/testData/diagnostics/tests/subtyping/kt-1457.javac.txt new file mode 100644 index 00000000000..724408aee3d --- /dev/null +++ b/compiler/testData/diagnostics/tests/subtyping/kt-1457.javac.txt @@ -0,0 +1,60 @@ +package + +public fun test(): kotlin.Unit + +public final class MyListOfPairs : java.util.ArrayList> { + public constructor MyListOfPairs() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: Pair): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: Pair): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection>): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection>): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: Pair): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection>): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): Pair! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): Pair + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: Pair): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator> + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: Pair): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator> + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator> + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: Pair): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection>): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): Pair + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection>): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: Pair): Pair + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList> + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} + +public final class Pair { + public constructor Pair(/*0*/ a: A, /*1*/ b: B) + public final val a: A + public final val b: B + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/subtyping/kt-1457.kt b/compiler/testData/diagnostics/tests/subtyping/kt-1457.kt index 6d2e490717e..7c0768cc801 100644 --- a/compiler/testData/diagnostics/tests/subtyping/kt-1457.kt +++ b/compiler/testData/diagnostics/tests/subtyping/kt-1457.kt @@ -1,4 +1,5 @@ // !CHECK_TYPE +// JAVAC_EXPECTED_FILE import java.util.ArrayList diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.javac.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.javac.txt new file mode 100644 index 00000000000..650254fa329 --- /dev/null +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.javac.txt @@ -0,0 +1,18 @@ +package + +public fun foo(/*0*/ javaClass: JavaClass): kotlin.String + +public/*package*/ interface I { + public abstract fun doIt(/*0*/ t: T!): T! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class JavaClass { + public constructor JavaClass() + public open fun doSomething(/*0*/ t: T!, /*1*/ anInt: kotlin.Int, /*2*/ i: I!): T! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt index aa8e182ca7b..c9781637d70 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: KotlinFile.kt fun foo(javaClass: JavaClass): String { return javaClass.doSomething("", 1) { s: String -> "" } diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.javac.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.javac.txt new file mode 100644 index 00000000000..7de2d3ca74a --- /dev/null +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.javac.txt @@ -0,0 +1,18 @@ +package + +public fun foo(/*0*/ javaClass: JavaClass): kotlin.String + +public/*package*/ interface I { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract fun run(/*0*/ t: T!): T! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class JavaClass { + public constructor JavaClass() + public open fun doSomething(/*0*/ t: T!, /*1*/ i: I!): T! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt index cf003292cd9..ab0f7d86bb2 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: KotlinFile.kt fun foo(javaClass: JavaClass): String { return javaClass.doSomething("") { it } diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.javac.txt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.javac.txt new file mode 100644 index 00000000000..a441d61a1b0 --- /dev/null +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.javac.txt @@ -0,0 +1,19 @@ +package + +public fun foo(/*0*/ javaClass: JavaClass): kotlin.Unit + +public/*package*/ interface I { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract fun run(/*0*/ t: T!): T! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class JavaClass { + public constructor JavaClass() + public open fun doSomething1(/*0*/ t: T!, /*1*/ x: X!, /*2*/ i: I!): T! + public open fun doSomething2(/*0*/ t: T!, /*1*/ x: X!, /*2*/ p: kotlin.Boolean, /*3*/ i: I!): T! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt index 862e33587fc..b1a3772167e 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: KotlinFile.kt fun foo(javaClass: JavaClass) { val a: String = javaClass.doSomething1("", 1) { p: String -> p } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionNIsUnresolved.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionNIsUnresolved.kt index c37380a8732..fdae0c893a7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionNIsUnresolved.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionNIsUnresolved.kt @@ -1,3 +1,4 @@ +// JAVAC_SKIP typealias Test1 = SuspendFunction0 typealias Test2 = kotlin.SuspendFunction0 typealias Test3 = kotlin.coroutines.SuspendFunction0 \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt index 05230e46ac2..9bc3f431b05 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.txt @@ -15,3 +15,17 @@ public open class K : foo.A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + +package foo { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public/*package*/ open fun bar(/*0*/ s: kotlin.Double): kotlin.Unit + private open fun foo(/*0*/ s: kotlin.Int): kotlin.Unit + } +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.javac.txt b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.javac.txt new file mode 100644 index 00000000000..34c6ef3a574 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.javac.txt @@ -0,0 +1,91 @@ +package + +public interface Base { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class Derived : Base, Other { + public constructor Derived() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class DerivedWrapper : Wrapper> { + public constructor DerivedWrapper(/*0*/ v: Derived<*>) + public final override /*1*/ /*fake_override*/ val v: Derived<*> + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class Exotic : Base, Other { + public/*package*/ constructor Exotic(/*0*/ x: kotlin.Int) + public/*package*/ final var x: kotlin.Int + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class ExoticWrapper : Wrapper { + public constructor ExoticWrapper(/*0*/ v: Exotic) + public final override /*1*/ /*fake_override*/ val v: Exotic + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class My { + public constructor My(/*0*/ x: kotlin.Int) + public final val wrapper: Wrapper<*>! + public final val x: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public object MyBase { + private constructor MyBase() + public final fun derived(): Derived + public final fun derivedWrapper(): DerivedWrapper + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun exotic(/*0*/ x: kotlin.Int): Exotic + public final fun exoticWrapper(/*0*/ x: kotlin.Int): ExoticWrapper + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public interface Other { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public/*package*/ open class Properties { + public/*package*/ constructor Properties() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public/*package*/ open fun calcVal(/*0*/ initializer: (() -> T!)!): Val! +} + +public/*package*/ open class Val { + public/*package*/ constructor Val(/*0*/ initializer: (() -> T!)!) + public/*package*/ final var initializer: (() -> T!)! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open operator fun getValue(/*0*/ instance: kotlin.Any!, /*1*/ metadata: kotlin.Any!): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class Wrapper { + public constructor Wrapper(/*0*/ v: T) + public final val v: T + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt index 1a8ab6b7ade..c5bb85d36d6 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: Base.java public interface Base {} diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.javac.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.javac.txt new file mode 100644 index 00000000000..067be5f8238 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.javac.txt @@ -0,0 +1,29 @@ +package + +public fun bar(): kotlin.String? +public fun foo(): kotlin.Unit + +@kotlin.jvm.PurelyImplements(value = "kotlin.collections.MutableCollection") public/*package*/ open class A : java.util.AbstractCollection, kotlin.collections.MutableCollection { + public/*package*/ constructor A() + public open override /*2*/ val size: kotlin.Int + public open override /*2*/ /*fake_override*/ fun add(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun contains(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + @java.lang.Override public open override /*2*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*2*/ /*fake_override*/ fun remove(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt index ca656c91e23..a02b987d6d4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt @@ -1,6 +1,7 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE +// JAVAC_EXPECTED_FILE -import java.util.* +import java.util.*; // FILE: A.java @kotlin.jvm.PurelyImplements("kotlin.collections.MutableCollection") diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.javac.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.javac.txt new file mode 100644 index 00000000000..f9b05ee1b9a --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.javac.txt @@ -0,0 +1,43 @@ +package + +public fun bar(): kotlin.String? +public fun foo(): kotlin.Unit + +@kotlin.jvm.PurelyImplements(value = "kotlin.collections.MutableList") public/*package*/ open class A : java.util.AbstractList, kotlin.collections.MutableList { + public/*package*/ constructor A() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public open override /*2*/ val size: kotlin.Int + public open override /*2*/ /*fake_override*/ fun add(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun contains(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public open override /*2*/ fun get(/*0*/ index: kotlin.Int): T + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun indexOf(/*0*/ element: T): kotlin.Int + public open override /*2*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*2*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T): kotlin.Int + public open override /*2*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*2*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun remove(/*0*/ element: T): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun removeAt(/*0*/ index: kotlin.Int): T + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*2*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T): T + public open override /*2*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt index 1ecbbf61e94..2db8b8487dc 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt @@ -1,6 +1,7 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE +// JAVAC_EXPECTED_FILE -import java.util.* +import java.util.*; // FILE: A.java @kotlin.jvm.PurelyImplements("kotlin.collections.MutableList") diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.javac.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.javac.txt new file mode 100644 index 00000000000..466e3c46309 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.javac.txt @@ -0,0 +1,82 @@ +package + +public val x: A +public val y: B + +@kotlin.jvm.PurelyImplements(value = "") public open class A : java.util.AbstractList { + public constructor A() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public open override /*1*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public open override /*1*/ fun get(/*0*/ index: kotlin.Int): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): T! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T!): T! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} + +@kotlin.jvm.PurelyImplements(value = "[INVALID]") public open class B : java.util.AbstractList { + public constructor B() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): T! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T!): T! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt index a98edb93e9b..80c8397edc9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt @@ -1,7 +1,8 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE +// JAVAC_EXPECTED_FILE // FILE: A.java -import java.util.* +import java.util.*; @kotlin.jvm.PurelyImplements("") public class A extends AbstractList { @@ -17,7 +18,7 @@ public class A extends AbstractList { } // FILE: B.java -import java.util.* +import java.util.*; @kotlin.jvm.PurelyImplements("[INVALID]") public class B extends AbstractList {} diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.javac.txt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.javac.txt new file mode 100644 index 00000000000..6db85c53cc2 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.javac.txt @@ -0,0 +1,43 @@ +package + +public fun bar(): kotlin.String? +public fun foo(): kotlin.Unit + +@kotlin.jvm.PurelyImplements(value = "kotlin.collections.MutableList") public/*package*/ open class A : java.util.AbstractList { + public/*package*/ constructor A() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public open override /*1*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: T!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public open override /*1*/ fun get(/*0*/ index: kotlin.Int): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: T!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): T! + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: T!): T! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt index b57b94d8432..1fb450aad86 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt @@ -1,6 +1,7 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE +// JAVAC_EXPECTED_FILE -import java.util.* +import java.util.*; // FILE: A.java @kotlin.jvm.PurelyImplements("kotlin.collections.MutableList") diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.txt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.txt index 6926e3b907d..288164f4135 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.txt @@ -7,3 +7,16 @@ package a { package b { public fun test(): kotlin.Unit } + +package s { + + public open class SamConstructor { + public constructor SamConstructor(/*0*/ r: java.lang.Runnable!) + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun foo(/*0*/ r: java.lang.Runnable!): kotlin.Unit + } +} diff --git a/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/parametersAreNonnullByDefaultPackage.txt b/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/parametersAreNonnullByDefaultPackage.txt index 6b6fb798d28..20b10badb15 100644 --- a/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/parametersAreNonnullByDefaultPackage.txt +++ b/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/parametersAreNonnullByDefaultPackage.txt @@ -25,3 +25,29 @@ public open class A2 { package public fun main(/*0*/ a: test.A, /*1*/ a2: test2.A2): kotlin.Unit + +package test { + + public open class A { + public constructor A() + @javax.annotation.Nullable public final var field: kotlin.String? + @javax.annotation.Nonnull public open fun bar(): kotlin.String + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(/*0*/ q: kotlin.String, /*1*/ @javax.annotation.Nonnull x: kotlin.String, /*2*/ @javax.annotation.CheckForNull y: kotlin.CharSequence?): kotlin.String! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package test2 { + + public open class A2 { + public constructor A2() + @javax.annotation.Nullable public final var field: kotlin.String? + @javax.annotation.Nonnull public open fun bar(): kotlin.String + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(/*0*/ q: kotlin.String!, /*1*/ @javax.annotation.Nonnull x: kotlin.String, /*2*/ @javax.annotation.CheckForNull y: kotlin.CharSequence?): kotlin.String! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullable.txt b/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullable.txt index 45b243c67ee..7c2f2423e7d 100644 --- a/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullable.txt +++ b/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullable.txt @@ -12,3 +12,20 @@ public fun main(/*0*/ a: A): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package spr { + + @kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.METHOD, ElementType.PARAMETER}) public final annotation class NonNullApi : kotlin.Annotation { + public constructor NonNullApi() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierNickname public final annotation class Nullable : kotlin.Annotation { + public constructor Nullable() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullablePackage.txt b/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullablePackage.txt index 615020e4e92..24426ef883a 100644 --- a/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullablePackage.txt +++ b/compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullablePackage.txt @@ -14,3 +14,34 @@ public open class A { package public fun main(/*0*/ a: test.A): kotlin.Unit + +package spr { + + @kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.METHOD, ElementType.PARAMETER}) public final annotation class NonNullApi : kotlin.Annotation { + public constructor NonNullApi() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierNickname public final annotation class Nullable : kotlin.Annotation { + public constructor Nullable() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package test { + + public open class A { + public constructor A() + public final var field: kotlin.String! + public open fun bar(): kotlin.String + @spr.Nullable public open fun baz(): kotlin.collections.(Mutable)List? + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(/*0*/ x: kotlin.String, /*1*/ @spr.Nullable y: kotlin.CharSequence?): kotlin.String + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/springNullableWithTypeUse.txt b/compiler/testData/foreignAnnotationsJava8/tests/springNullableWithTypeUse.txt index 188ef5ec1f0..5dae5b01230 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/springNullableWithTypeUse.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/springNullableWithTypeUse.txt @@ -12,3 +12,20 @@ public fun main(/*0*/ a: A): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + +package spr { + + @kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NonNullApi : kotlin.Annotation { + public constructor NonNullApi() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierNickname public final annotation class Nullable : kotlin.Annotation { + public constructor Nullable() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.javac.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.javac.txt new file mode 100644 index 00000000000..6b3c6d1e559 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.javac.txt @@ -0,0 +1,66 @@ +package + +public/*package*/ open class AnnotatedTypeArguments { + public/*package*/ constructor AnnotatedTypeArguments() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public/*package*/ open inner class A { + public/*package*/ constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open fun foo(/*0*/ x: L!, S<*>!>!>!): L!, S<*>!>!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class B : AnnotatedTypeArguments.A { + public/*package*/ constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull L, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>): @org.checkerframework.checker.nullness.qual.Nullable L, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class C : AnnotatedTypeArguments.B { + public/*package*/ constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open override /*1*/ fun foo(/*0*/ x: L, S<*>>!>): L, S<*>>!>? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class D1 : AnnotatedTypeArguments.C { + public/*package*/ constructor D1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open override /*1*/ fun foo(/*0*/ x: L, S<*>>!>): L, S<*>>!>? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class D2 : AnnotatedTypeArguments.C { + public/*package*/ constructor D2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable L, S<*>>!>!): @org.checkerframework.checker.nullness.qual.NonNull L, S<*>>!> + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +public/*package*/ interface L { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public/*package*/ interface P { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public/*package*/ interface S { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt index ea859aa2d71..8e3a2e7193f 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: AnnotatedTypeArguments.java import org.checkerframework.checker.nullness.qual.*; diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.javac.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.javac.txt new file mode 100644 index 00000000000..db52738da3a --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.javac.txt @@ -0,0 +1,56 @@ +package + +public/*package*/ open class Outer { + public/*package*/ constructor Outer() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public/*package*/ open inner class A { + public/*package*/ constructor A() + public/*package*/ open fun bar(/*0*/ x: Y!): X! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open fun foo(/*0*/ x: K!): V! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class B : Outer.A { + public/*package*/ constructor B() + @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull Y<@org.checkerframework.checker.nullness.qual.NonNull R>): @org.checkerframework.checker.nullness.qual.Nullable X<@org.checkerframework.checker.nullness.qual.Nullable R!>? + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable T1?): @org.checkerframework.checker.nullness.qual.NonNull T2 + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class C : Outer.B { + public/*package*/ constructor C() + @java.lang.Override public/*package*/ open override /*1*/ fun bar(/*0*/ x: Y): X? + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public/*package*/ open override /*1*/ fun foo(/*0*/ x: I?): J + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class D : Outer.C { + public/*package*/ constructor D() + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable Y<@org.checkerframework.checker.nullness.qual.Nullable F!>!): @org.checkerframework.checker.nullness.qual.NonNull X<@org.checkerframework.checker.nullness.qual.NonNull F!> + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable U?): @org.checkerframework.checker.nullness.qual.NonNull W + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +public/*package*/ interface X { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public/*package*/ interface Y { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt index a9fec425654..ae014ffe8a6 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: Outer.java import org.checkerframework.checker.nullness.qual.*; diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.javac.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.javac.txt new file mode 100644 index 00000000000..18f4b083ad4 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.javac.txt @@ -0,0 +1,68 @@ +package + +public/*package*/ interface Base { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public/*package*/ interface Derived : Base { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public/*package*/ open class Outer { + public/*package*/ constructor Outer() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public/*package*/ open inner class A { + public/*package*/ constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class B : Outer.A { + public/*package*/ constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public/*package*/ open override /*1*/ fun foo(): Base? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class C : Outer.A { + public/*package*/ constructor C() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Base + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class D : Outer.A { + public/*package*/ constructor D() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public/*package*/ open override /*1*/ fun foo(): Derived? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class E : Outer.A { + public/*package*/ constructor E() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public/*package*/ open inner class F : Outer.A { + public/*package*/ constructor F() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!> + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt index c49b106d15b..a590777d855 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE // FILE: Outer.java import org.checkerframework.checker.nullness.qual.*; diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt index 03b8d921217..ae567c9733d 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt @@ -1,6 +1,6 @@ // FILE: A.java -import org.checkerframework.checker.nullness.qual.* +import org.checkerframework.checker.nullness.qual.*; public class A { @Nullable Base<@NonNull String> foo() { return null; } diff --git a/compiler/testData/javac/diagnostics/tests/Annotations.kt b/compiler/testData/javac/diagnostics/tests/Annotations.kt new file mode 100644 index 00000000000..0cbf780ee5a --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/Annotations.kt @@ -0,0 +1,52 @@ +// FILE: a/ann.java +package a; + +public @interface ann { + Class value(); +} + +// FILE: a/x.java +package a; + +@ann(String.class) +public class x { + @ann2(value = { @ann1(a = "a" + "b", i = 1 * 2), @ann1(a = "b", i = 2), @ann1(a = "c", i = 3) }, i = 42) + public String method() { return null; } + + @ann3((1 + 1)) + public String method2() { return null; } +} + +// FILE: a/ann1.java +package a; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@interface ann1 { + public String a(); + public int i(); +} +// FILE: a/ann2.java +package a; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@interface ann2 { + public ann1[] value() default {}; + public int i(); +} + +// FILE: a/ann3.java +package a; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@interface ann3 { + public int value(); +} \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/Annotations.txt b/compiler/testData/javac/diagnostics/tests/Annotations.txt new file mode 100644 index 00000000000..4d587147dba --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/Annotations.txt @@ -0,0 +1,47 @@ +package + +package a { + + public final annotation class ann : kotlin.Annotation { + public constructor ann(/*0*/ value: kotlin.reflect.KClass<(raw) kotlin.Any>) + public final val value: kotlin.reflect.KClass<(raw) kotlin.Any> + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public/*package*/ final annotation class ann1 : kotlin.Annotation { + public/*package*/ constructor ann1(/*0*/ a: kotlin.String, /*1*/ i: kotlin.Int) + public final val a: kotlin.String + public final val i: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public/*package*/ final annotation class ann2 : kotlin.Annotation { + public/*package*/ constructor ann2(/*0*/ vararg value: a.ann1 /*kotlin.Array*/ = ..., /*1*/ i: kotlin.Int) + public final val i: kotlin.Int + public final val value: kotlin.Array + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public/*package*/ final annotation class ann3 : kotlin.Annotation { + public/*package*/ constructor ann3(/*0*/ value: kotlin.Int) + public final val value: kotlin.Int + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @a.ann(value = kotlin.String::class) public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + @a.ann2(i = 42, value = {a.ann1(a = "ab", i = 2), a.ann1(a = "b", i = 2), a.ann1(a = "c", i = 3)}) public open fun method(): kotlin.String! + @a.ann3(value = 2) public open fun method2(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/ConstantValues.kt b/compiler/testData/javac/diagnostics/tests/ConstantValues.kt new file mode 100644 index 00000000000..a40f39e8d21 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/ConstantValues.kt @@ -0,0 +1,45 @@ +// FILE: a/x.java +package a; + +public class x { + + public static final String STR = "STR"; + public static final String STR2 = "STR" + STR; + public static final int I = (15 / 5) + 3; + public static final int IMAX = Integer.MAX_VALUE; + public static final int I2 = Integer.MIN_VALUE + x.IMAX - 1; + public static final double D = 25.0 - 15.0; + public static final String NULL = null; + public static final int VAL = 15 % 3; + public static final boolean VAL1 = false; + public static final boolean VAL2 = VAL1 && true; + public static final boolean VAL3 = VAL1 || VAL2; + public static final boolean VAL4 = I > I2; + public static final boolean VAL5 = I < I2; + public static final boolean VAL6 = I <= D; + public static final boolean VAL7 = I >= D; + public static final boolean VAL8 = VAL1 == VAL2; + public static final boolean VAL9 = VAL1 != VAL2; + public static final boolean VAL10 = !VAL9; + public static final boolean VAL11 = STR instanceof String; + public static final byte B = 10>>1; + public static final byte B1 = 10<<1; + public static final byte B2 = 1 & 0; + public static final byte B3 = 1 | 0; + public static final byte B4 = ~1; + public static final byte B5 = 1 ^ 1; + public static final byte B6 = B>>>1; + +} + +// FILE: test.kt +package a + +val v1 = x.STR +val v2 = x.STR2 +val v3 = x.I +val v4 = x.IMAX +val v5 = x.I2 +val v6 = x.D +val v7 = x.NULL +val v8 = x.VAL \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/ConstantValues.txt b/compiler/testData/javac/diagnostics/tests/ConstantValues.txt new file mode 100644 index 00000000000..0446796f268 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/ConstantValues.txt @@ -0,0 +1,47 @@ +package + +package a { + public val v1: kotlin.String = "STR" + public val v2: kotlin.String = "STRSTR" + public val v3: kotlin.Int = 6 + public val v4: kotlin.Int = 2147483647 + public val v5: kotlin.Int = -2 + public val v6: kotlin.Double = 10.0.toDouble() + public val v7: kotlin.String! + public val v8: kotlin.Int = 0 + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public const final val B: kotlin.Byte = 5.toByte() + public const final val B1: kotlin.Byte = 20.toByte() + public const final val B2: kotlin.Byte = 0.toByte() + public const final val B3: kotlin.Byte = 1.toByte() + public const final val B4: kotlin.Byte = -2.toByte() + public const final val B5: kotlin.Byte = 0.toByte() + public const final val B6: kotlin.Byte = 2.toByte() + public const final val D: kotlin.Double = 10.0.toDouble() + public const final val I: kotlin.Int = 6 + public const final val I2: kotlin.Int = -2 + public const final val IMAX: kotlin.Int = 2147483647 + public const final val NULL: kotlin.String! + public const final val STR: kotlin.String = "STR" + public const final val STR2: kotlin.String = "STRSTR" + public const final val VAL: kotlin.Int = 0 + public const final val VAL1: kotlin.Boolean = false + public const final val VAL10: kotlin.Boolean = true + public const final val VAL11: kotlin.Boolean + public const final val VAL2: kotlin.Boolean = false + public const final val VAL3: kotlin.Boolean = false + public const final val VAL4: kotlin.Boolean = true + public const final val VAL5: kotlin.Boolean = false + public const final val VAL6: kotlin.Boolean = true + public const final val VAL7: kotlin.Boolean = false + public const final val VAL8: kotlin.Boolean = true + public const final val VAL9: kotlin.Boolean = false + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt new file mode 100644 index 00000000000..59b8fa8f8c6 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt @@ -0,0 +1,27 @@ +// FILE: a/x.java +package a; + +public class x {} + +// FILE: b/x.java +package b; + +public class x {} + +// FILE: c/d.java +package c; + +import a.*; +import b.*; + +public class d { + public x x() { return null; } +} + +// FILE: c/c.kt +package c + +import a.* +import b.* + +fun test(): x = d().x() diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.txt b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.txt new file mode 100644 index 00000000000..7ce7b375630 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.txt @@ -0,0 +1,33 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package c { + public fun test(): [ERROR : x] + + public open class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + public open fun x(): x! + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt new file mode 100644 index 00000000000..9d5e05f302f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt @@ -0,0 +1,26 @@ +// FILE: a/X.java +package a; + +public class X {} + +// FILE: b/X.java +package b; + +public class X {} + +// FILE: c/Test.java +package c; + +import a.X; +import b.*; + +public class Test { + + public X test() { return null; }; + +} + +// FILE: c.kt +package c + +fun test() = Test().test() diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.txt b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.txt new file mode 100644 index 00000000000..d9bc09ae5e4 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.txt @@ -0,0 +1,33 @@ +package + +package a { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package c { + public fun test(): a.X! + + public open class Test { + public constructor Test() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): a.X! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt b/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt new file mode 100644 index 00000000000..895418c20a9 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt @@ -0,0 +1,30 @@ +// FILE: b.kt +package b + +object O {} + +// FILE: c.kt +package c + +object O {} + +// FILE: a/a.java +package a; + +import b.O; +import c.O; + +public abstract class a { + + public O getO() { return null; } + +} + +// FILE: a.kt +package d + +import a.a + +class A : a() + +fun test() = A().getO() diff --git a/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.txt b/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.txt new file mode 100644 index 00000000000..bb5675eb71e --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.txt @@ -0,0 +1,44 @@ +package + +package a { + + public abstract class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getO(): O! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + + public object O { + private constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package c { + + public object O { + private constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package d { + public fun test(): O! + + public final class A : a.a { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun getO(): O! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt new file mode 100644 index 00000000000..b25a38a5a6b --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt @@ -0,0 +1,25 @@ +// FILE: a/X.java +package a; + +public class X {} + +// FILE: b/X.java +package b; + +public class X {} + +// FILE: b/A.java +package b; + +import a.*; + +public class A { + + public X getX() { return null; } + +} + +// FILE: b.kt +package b + +fun test() = A().getX() diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.txt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.txt new file mode 100644 index 00000000000..6712c35094d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.txt @@ -0,0 +1,30 @@ +package + +package a { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + public fun test(): b.X! + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getX(): b.X! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt new file mode 100644 index 00000000000..a4021952978 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt @@ -0,0 +1,27 @@ +// FILE: a/Y.java +package a; + +public class Y { + public void test() {} +} + +// FILE: b/Y.java +package b; + +public class Y {} + +// FILE: b/T.java +package b; + +import a.Y; + +public class T { + + public Y getY() { return null; } + +} + +// FILE: b/b.kt +package b + +fun test() = T().getY().test() diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.txt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.txt new file mode 100644 index 00000000000..45e3c2ba099 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.txt @@ -0,0 +1,31 @@ +package + +package a { + + public open class Y { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + public fun test(): kotlin.Unit + + public open class T { + public constructor T() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): a.Y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Y { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt new file mode 100644 index 00000000000..a3fbb43864b --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt @@ -0,0 +1,30 @@ +// FILE: a/X.java +package a; + +public class X { + public void test() {} + + public static class Y {} + +} + +// FILE: b/Y.java +package b; + +public class Y {} + +// FILE: b/T.java +package b; + +import a.X.Y; + +public class T { + + public Y getY() { return null; } + +} + +// FILE: b/b.kt +package b + +fun test() = T().getY() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.txt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.txt new file mode 100644 index 00000000000..78b5eac8fae --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.txt @@ -0,0 +1,38 @@ +package + +package a { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Y { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package b { + public fun test(): a.X.Y! + + public open class T { + public constructor T() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): a.X.Y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Y { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt new file mode 100644 index 00000000000..1933ba18a31 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt @@ -0,0 +1,30 @@ +// FILE: a/X.java +package a; + +public class X { + public void test() {} + + public static class Y {} + +} + +// FILE: b/Y.java +package b; + +public class Y {} + +// FILE: b/T.java +package b; + +import a.X.*; + +public class T { + + public Y getY() { return null; } + +} + +// FILE: b/b.kt +package b + +fun test() = T().getY() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.txt b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.txt new file mode 100644 index 00000000000..48fc3a40f42 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.txt @@ -0,0 +1,38 @@ +package + +package a { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Y { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package b { + public fun test(): b.Y! + + public open class T { + public constructor T() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): b.Y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class Y { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt b/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt new file mode 100644 index 00000000000..015c27ce30c --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt @@ -0,0 +1,25 @@ +// FILE: a/x.java +package a; + +public class x {} + +// FILE: b/x.java +package b; + +public class x {} + +// FILE: b/test.java +package b; + +import a.x; + +public class test { + + public x getX() { return null; } + +} + +// FILE: b/test.kt +package b + +fun test1() = test().getX() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.txt b/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.txt new file mode 100644 index 00000000000..359d53b5ff5 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.txt @@ -0,0 +1,30 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + public fun test1(): a.x<*>! + + public open class test { + public constructor test() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getX(): a.x<*>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt b/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt new file mode 100644 index 00000000000..dc03ff8bacc --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt @@ -0,0 +1,19 @@ +// FILE: p/Foo.java +package p; + +public class Foo { + protected static class Nested {} +} + +// FILE: foo.kt +package a + +import p.Foo +import p.Foo.Nested + +class Bar : Foo() { + protected fun foo(): Nested? = null +} + +private fun foo(): Nested? = null +private fun bar(): p.Foo.Nested? = null diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.txt b/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.txt new file mode 100644 index 00000000000..afbc7afdd01 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.txt @@ -0,0 +1,31 @@ +package + +package a { + private fun bar(): p.Foo.Nested? + private fun foo(): p.Foo.Nested? + + public final class Bar : p.Foo { + public constructor Bar() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected final fun foo(): p.Foo.Nested? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package p { + + public open class Foo { + public constructor Foo() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + protected/*protected static*/ open class Nested { + protected/*protected and package*/ constructor Nested() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt new file mode 100644 index 00000000000..dd23fa50cd0 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt @@ -0,0 +1,21 @@ +// FILE: weatherForecast/Weather.java +package weatherForecast; + +public class Weather { + public void test() {} +} + +// FILE: a/a.java +package a; + +import weatherForecast.Weather; +import weatherForecast.Weather; + +public class a { + public Weather forecast() { return null; } +} + +// FILE: a.kt +package a + +fun test() = a().forecast().test() diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.txt b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.txt new file mode 100644 index 00000000000..d7cd318358b --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.txt @@ -0,0 +1,24 @@ +package + +package a { + public fun test(): kotlin.Unit + + public open class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun forecast(): weatherForecast.Weather! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package weatherForecast { + + public open class Weather { + public constructor Weather() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt new file mode 100644 index 00000000000..80e01409fef --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt @@ -0,0 +1,21 @@ +// FILE: weatherForecast/Weather.java +package weatherForecast; + +public class Weather { + public void test() {} +} + +// FILE: a/A.java +package a; + +import weatherForecast.*; +import weatherForecast.*; + +public class A { + public Weather getWeather() { return null; } +} + +// FILE: a.kt +package a + +fun test() = A().getWeather().test() diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.txt b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.txt new file mode 100644 index 00000000000..56893472278 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.txt @@ -0,0 +1,24 @@ +package + +package a { + public fun test(): kotlin.Unit + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getWeather(): weatherForecast.Weather! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package weatherForecast { + + public open class Weather { + public constructor Weather() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt b/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt new file mode 100644 index 00000000000..2575f29b93f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt @@ -0,0 +1,37 @@ +// FILE: a/B.java +package a; + +public class B {} + +// FILE: a/D.java +package a; + +public class D { + public static class B {} +} + +// FILE: b/A1.java +package b; + +import a.B; +import a.D.B; + +public class A1 { + public B getB() { return null; } +} + +// FILE: b/A2.java +package b; + +import a.*; +import a.D.*; + +public class A2 { + public B getB() { return null; } +} + +// FILE: a.kt +package b + +fun test() = A1().getB() +fun test2() = A2().getB() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.txt b/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.txt new file mode 100644 index 00000000000..8eafd6bd017 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.txt @@ -0,0 +1,46 @@ +package + +package a { + + public open class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class D { + public constructor D() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package b { + public fun test(): B! + public fun test2(): B! + + public open class A1 { + public constructor A1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): B! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class A2 { + public constructor A2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): B! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt b/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt new file mode 100644 index 00000000000..b3f09a6fb46 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt @@ -0,0 +1,39 @@ +// FILE: a/A.java +package a; + +public class A { + public static class B {} +} + +// FILE: a/D.java +package a; + +public class D { + public static class B {} +} + +// FILE: b/A1.java +package b; + +import a.A.B; +import a.D.B; + +public class A1 { + public B getB() { return null; } +} + +// FILE: b/A2.java +package b; + +import a.A.*; +import a.D.*; + +public class A2 { + public B getB() { return null; } +} + +// FILE: a.kt +package b + +fun test() = A1().getB() +fun test2() = A2().getB() diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.txt b/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.txt new file mode 100644 index 00000000000..d415a9f8988 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.txt @@ -0,0 +1,53 @@ +package + +package a { + + public open class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class D { + public constructor D() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package b { + public fun test(): B! + public fun test2(): B! + + public open class A1 { + public constructor A1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): B! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class A2 { + public constructor A2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): B! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt b/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt new file mode 100644 index 00000000000..02059160140 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt @@ -0,0 +1,31 @@ +// FILE: a/x.java +package a; + +public class x {} + +// FILE: b/x.java +package b; + +public class x {} + +// FILE: c/x.java +package c; + +public class x {} + +// FILE: c/y.java +package c; + +import a.x; +import b.*; + +public class y { + + public x getX() { return null; } + +} + +// FILE: c/test.kt +package c + +fun test() = y().getX() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.txt b/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.txt new file mode 100644 index 00000000000..9869d0acddb --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.txt @@ -0,0 +1,40 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package c { + public fun test(): a.x! + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getX(): a.x! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt b/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt new file mode 100644 index 00000000000..d999c260541 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt @@ -0,0 +1,19 @@ +// FILE: p/Foo.java +package p; + +class Foo { + public static class Nested {} +} + +// FILE: foo.kt +package a + +import p.Foo +import p.Foo.Nested + +class Bar : Foo() { + protected fun foo(): Nested? = null +} + +private fun foo(): Nested? = null +private fun bar(): p.Foo.Nested? = null \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.txt b/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.txt new file mode 100644 index 00000000000..5b87a22c9e1 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.txt @@ -0,0 +1,31 @@ +package + +package a { + private fun bar(): p.Foo.Nested? + private fun foo(): p.Foo.Nested? + + public final class Bar : p.Foo { + public constructor Bar() + invisible_fake open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + protected final fun foo(): p.Foo.Nested? + invisible_fake open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package p { + + public/*package*/ open class Foo { + public/*package*/ constructor Foo() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Nested { + public constructor Nested() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt new file mode 100644 index 00000000000..8cee97895ed --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt @@ -0,0 +1,42 @@ +// FILE: a/b.java +package a; + +public class b { + + public void a_b() {} + + public class c { + public void a_bc() {} + } +} + +// FILE: a.java + +public class a { + + public void _a() {} + + public class b { + public void _ab() {} + } + +} + +// FILE: c.java + +import a.b; + +public class c { + public b getB() { return null; } +} + +// FILE: c2.java + +public class c2 { + public a.b getB() { return null; } +} + +// FILE: e.kt + +fun test() = c().getB().c().a_bc() +fun test2() = c2().getB()._ab() diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.txt b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.txt new file mode 100644 index 00000000000..a1f7af7d5a1 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.txt @@ -0,0 +1,55 @@ +package + +public fun test(): kotlin.Unit +public fun test2(): kotlin.Unit + +public open class a { + public constructor a() + public open fun _a(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class b { + public constructor b() + public open fun _ab(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +public open class c { + public constructor c() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public open class c2 { + public constructor c2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +package a { + + public open class b { + public constructor b() + public open fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class c { + public constructor c() + public open fun a_bc(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt new file mode 100644 index 00000000000..73947aaad2e --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt @@ -0,0 +1,46 @@ +// FILE: foo/a/b.java +package foo.a; + +public class b { + + public void a_b() {} + + public class c { + public void a_bc() {} + } +} + +// FILE: foo/a.java +package foo; + +public class a { + + public void _a() {} + + public class b { + public void _ab() {} + } + +} + +// FILE: foo/c.java +package foo; + +import foo.a.b; + +public class c { + public b getB() { return null; } +} + +// FILE: foo/c2.java +package foo; + +public class c2 { + public a.b getB() { return null; } +} + +// FILE: e.kt +package foo + +fun test() = c().getB().c().a_bc() +fun test2() = c2().getB()._ab() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.txt b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.txt new file mode 100644 index 00000000000..2fa5d8712d7 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.txt @@ -0,0 +1,57 @@ +package + +package foo { + public fun test(): kotlin.Unit + public fun test2(): kotlin.Unit + + public open class a { + public constructor a() + public open fun _a(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class b { + public constructor b() + public open fun _ab(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class c { + public constructor c() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): foo.a.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class c2 { + public constructor c2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): foo.a.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + package foo.a { + + public open class b { + public constructor b() + public open fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class c { + public constructor c() + public open fun a_bc(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt b/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt new file mode 100644 index 00000000000..d8ed0041f10 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt @@ -0,0 +1,19 @@ +// FILE: a/d.java +package a; + +public class d { + + public static class Inner extends d { + + public class Y extends d.Inner { + + public class Z extends d.Inner.Y { + + public class N extends d.Inner.Y.Z {} + } + + } + + } + +} \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.txt b/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.txt new file mode 100644 index 00000000000..03ba6c6a300 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.txt @@ -0,0 +1,39 @@ +package + +package a { + + public open class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Inner : a.d { + public constructor Inner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Y /*captured type parameters: /*1*/ X : kotlin.Any!*/ : a.d.Inner { + public constructor Y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Z /*captured type parameters: /*1*/ C : kotlin.Any!, /*2*/ X : kotlin.Any!*/ : a.d.Inner.Y { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class N /*captured type parameters: /*1*/ Z : kotlin.Any!, /*2*/ C : kotlin.Any!, /*3*/ X : kotlin.Any!*/ : a.d.Inner.Y.Z { + public constructor N() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt new file mode 100644 index 00000000000..04ea71dba8b --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt @@ -0,0 +1,27 @@ +// FILE: a/x.java +package a; + +public class x { + public class Z {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/y.java +package a; + +public class y extends x implements i { + + public Z getZ() { return null; } + +} + +// FILE: test.kt +package a + +fun test() = y().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.txt new file mode 100644 index 00000000000..8fd21fbefe3 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.txt @@ -0,0 +1,40 @@ +package + +package a { + public fun test(): Z! + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class y : a.x, a.i { + public constructor y() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): Z! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt new file mode 100644 index 00000000000..14278b34f32 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt @@ -0,0 +1,30 @@ +// FILE: a/x.java +package a; + +public class x { + public class Z {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i {} + +// FILE: a/y.java +package a; + +public class y extends x implements i2 { + public Z getZ() { return null; } +} + +// FILE: test.kt +package a + +fun test() = y().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.txt new file mode 100644 index 00000000000..0922378b0d6 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.txt @@ -0,0 +1,46 @@ +package + +package a { + public fun test(): Z! + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 : a.i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class y : a.x, a.i2 { + public constructor y() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): Z! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt new file mode 100644 index 00000000000..78edd294c15 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt @@ -0,0 +1,25 @@ +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/i2.java +package a; + +public interface i2 { + public class Z {} +} + +// FILE: a/x.java +package a; + +public class x implements i, i2 { + public Z getZ() { return null; } +} + +// FILE: test.kt +package a + +fun test() = x().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.txt new file mode 100644 index 00000000000..739ee3823dd --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.txt @@ -0,0 +1,39 @@ +package + +package a { + public fun test(): Z! + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class x : a.i, a.i2 { + public constructor x() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): Z! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt new file mode 100644 index 00000000000..2b34576f96e --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt @@ -0,0 +1,47 @@ +// FILE: a/x.java +package a; + +public class x { + class O {} +} + +// FILE: a/x1.java +package a; + +public class x1 extends x {} + +// FILE: a/x2.java +package a; + +public class x2 extends x1 {} + +// FILE: a/i.java +package a; + +public interface i { + public class O {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i { + public class O {} +} + +// FILE: a/i3.java +package a; + +public interface i3 extends i2 {} + +// FILE: a/test.java +package a; + +public class test extends x2 implements i3 { + public O getO() { return null; } +} + +// FILE: test.kt +package a + +fun test1() = test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.txt new file mode 100644 index 00000000000..f13897499c4 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.txt @@ -0,0 +1,73 @@ +package + +package a { + public fun test1(): O! + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 : a.i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i3 : a.i2 { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class test : a.x2, a.i3 { + public constructor test() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getO(): O! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public/*package*/ open inner class O { + public/*package*/ constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class x1 : a.x { + public constructor x1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x2 : a.x1 { + public constructor x2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt new file mode 100644 index 00000000000..bcfc722f6e2 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt @@ -0,0 +1,37 @@ +// FILE: test/UseKotlinInner.java +package test; + +public class UseKotlinInner extends KotlinClass { + + KotlinInner getKotlinInner() { return null; } + + JavaInner getJavaInner() { return null; } + + KotlinInner3 getKotlinInner3() { return null; } +} + +// FILE: test/JavaClass2.java +package test; + +public class JavaClass2 { + public static class JavaInner {} +} + +// FILE: test/UseKotlinInner.kt +package test + +open class KotlinClass : KotlinInterface.KotlinInner2() { + inner class KotlinInner +} + +interface KotlinInterface { + open class KotlinInner2 : JavaClass2() { + class KotlinInner3 + } +} + +private fun getKotlinInner() = UseKotlinInner().kotlinInner + +private fun getJavaInner() = UseKotlinInner().javaInner + +private fun getKotlinInner3() = UseKotlinInner().kotlinInner3 \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.txt new file mode 100644 index 00000000000..0e6dbb15467 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.txt @@ -0,0 +1,65 @@ +package + +package test { + private fun getJavaInner(): test.JavaClass2.JavaInner! + private fun getKotlinInner(): test.KotlinClass.KotlinInner! + private fun getKotlinInner3(): test.KotlinInterface.KotlinInner2.KotlinInner3! + + public open class JavaClass2 { + public constructor JavaClass2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class JavaInner { + public constructor JavaInner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class KotlinClass : test.KotlinInterface.KotlinInner2 { + public constructor KotlinClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final inner class KotlinInner { + public constructor KotlinInner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface KotlinInterface { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class KotlinInner2 : test.JavaClass2 { + public constructor KotlinInner2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final class KotlinInner3 { + public constructor KotlinInner3() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } + + public open class UseKotlinInner : test.KotlinClass { + public constructor UseKotlinInner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open fun getJavaInner(): test.JavaClass2.JavaInner! + public/*package*/ open fun getKotlinInner(): test.KotlinClass.KotlinInner! + public/*package*/ open fun getKotlinInner3(): test.KotlinInterface.KotlinInner2.KotlinInner3! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt new file mode 100644 index 00000000000..e8ca4211dfc --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt @@ -0,0 +1,30 @@ +// FILE: a/k.kt +package a + +open class k { + fun getK(): k? = null + fun getI(): i? = null + inner class i +} + +// FILE: a/y.java +package a; + +public class y { + public k getK() { return null; } +} + +// FILE: a/x.java +package a; + +public class x extends k { + public i getIFromJava() { return null; } +} + +// FILE: test.kt +package a + +fun test() = x().getK() +fun test2() = x().getI() +fun test3() = x().getIFromJava() +fun test4() = y().getK() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.txt new file mode 100644 index 00000000000..2f8a8410031 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.txt @@ -0,0 +1,42 @@ +package + +package a { + public fun test(): a.k? + public fun test2(): a.k.i? + public fun test3(): a.k.i! + public fun test4(): a.k! + + public open class k { + public constructor k() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun getI(): a.k.i? + public final fun getK(): a.k? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final inner class i { + public constructor i() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class x : a.k { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun getI(): a.k.i? + public open fun getIFromJava(): a.k.i! + public final override /*1*/ /*fake_override*/ fun getK(): a.k? + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getK(): a.k! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt new file mode 100644 index 00000000000..53fdd947891 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt @@ -0,0 +1,24 @@ +// FILE: a/x.java +package a; + +public class x { + + public class y {} + +} + +// FILE: a/b.java +package a; + +public class b extends x { + + public y getY() { return null; } + +} + +// FILE: test.kt +package test + +import a.b + +fun test() = b().getY() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.txt new file mode 100644 index 00000000000..a76f087ec0a --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.txt @@ -0,0 +1,30 @@ +package + +package a { + + public open class b : a.x { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): a.x.y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): a.x.y! +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt new file mode 100644 index 00000000000..0b470a8d6ae --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt @@ -0,0 +1,29 @@ +// FILE: a/x.java +package a; + +public class x { + public static class S { + public static class B {} + } +} + +// FILE: a/x1.java +package a; + +public class x1 extends x.S { + public B getB() { return null; } +} + +// FILE: a/x2.java +package a; + +public class x2 extends x.S { + public B getB() { return null; } +} + +// FILE: a/test.kt +package a + +fun test1() = x1().getB() +fun test2() = x2.B() +fun test3() = x2().getB() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.txt new file mode 100644 index 00000000000..077820baeec --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.txt @@ -0,0 +1,44 @@ +package + +package a { + public fun test1(): a.x.S.B! + public fun test2(): [ERROR : Error function type] + public fun test3(): kotlin.String! + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class S { + public constructor S() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class B { + public constructor B() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } + + public open class x1 : a.x.S { + public constructor x1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.S.B! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x2 : a.x.S { + public constructor x2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): B! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt new file mode 100644 index 00000000000..371115d35cb --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt @@ -0,0 +1,31 @@ +// FILE: a/x.java +package a; + +public class x { + + public class y {} + +} + +// FILE: a/y.java +package a; + +public class y extends x { + +} + +// FILE: a/c.java +package a; + +public class c extends y { + + public y getY() { return null; } + +} + +// FILE: test.kt +package test + +import a.c + +fun test() = c().getY() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.txt new file mode 100644 index 00000000000..361125370b4 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.txt @@ -0,0 +1,37 @@ +package + +package a { + + public open class c : a.y { + public constructor c() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): a.x.y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class y : a.x { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package test { + public fun test(): a.x.y! +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt new file mode 100644 index 00000000000..6f5fd69f83d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt @@ -0,0 +1,31 @@ +// FILE: a/x.java +package a; + +public class x { + + public class z {} + +} + +// FILE: a/y.java +package a; + +public class y extends x { + + public z getZ() { return null; } + + public class d { + + public z getZ() { return null; } + + } + +} + +// FILE: test.kt +package test + +import a.y + +fun test() = y().getZ() +fun test2() = y().d().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.txt new file mode 100644 index 00000000000..977ee181767 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.txt @@ -0,0 +1,39 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class z { + public constructor z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class y : a.x { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): a.x.z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): a.x.z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): a.x.z! + public fun test2(): a.x.z! +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt new file mode 100644 index 00000000000..3eab3443fbc --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt @@ -0,0 +1,24 @@ +// FILE: a/x.kt +package a + +open class x { + + inner class y + +} + +// FILE: a/b.java +package a; + +public class b extends x { + + public y getY() { return null; } + +} + +// FILE: test.kt +package test + +import a.b + +fun test() = b().getY() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.txt new file mode 100644 index 00000000000..ae293a4ba4f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.txt @@ -0,0 +1,30 @@ +package + +package a { + + public open class b : a.x { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): a.x.y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final inner class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): a.x.y! +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt b/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt new file mode 100644 index 00000000000..adee7f316ef --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt @@ -0,0 +1,26 @@ +// FILE: a/x.java +package a; + +public class x { + + public class z {} + +} + +// FILE: a/y.java +package a; + +public class y extends x { + + public z getZ() { return null; } + + public class z {} + +} + +// FILE: test.kt +package test + +import a.y + +fun test() = y().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.txt b/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.txt new file mode 100644 index 00000000000..ba45d205b22 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.txt @@ -0,0 +1,37 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class z { + public constructor z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class y : a.x { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): a.y.z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class z { + public constructor z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): a.y.z! +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt b/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt new file mode 100644 index 00000000000..7bc38a7b79d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt @@ -0,0 +1,43 @@ +// FILE: a/x.java +package a; + +public interface x { + + public class d {} + + public class z {} + + public class o {} +} + +// FILE: a/b.java +package a; + +public interface b extends x { + + public class y {} + +} + +// FILE: a/c.java +package a; + +public class c implements x { + + public class d {} + +} + +// FILE: a/f.java +package a; + +public class f extends c implements b { + + public class o {} + + public d getD() { return null; } + public y getY() { return null; } + public z getZ() { return null; } + public o getO() { return null; } + +} \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.txt b/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.txt new file mode 100644 index 00000000000..c4a900e7401 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.txt @@ -0,0 +1,76 @@ +package + +package a { + + public interface b : a.x { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class c : a.x { + public constructor c() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class f : a.c, a.b { + public constructor f() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getD(): a.c.d! + public open fun getO(): a.f.o! + public open fun getY(): a.b.y! + public open fun getZ(): a.x.z! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class o { + public constructor o() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface x { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class o { + public constructor o() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class z { + public constructor z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt new file mode 100644 index 00000000000..66a664ebaaf --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt @@ -0,0 +1,47 @@ +// FILE: a/x.java +package a; + +public class x { + private class O {} +} + +// FILE: a/x1.java +package a; + +public class x1 extends x {} + +// FILE: a/x2.java +package a; + +public class x2 extends x1 {} + +// FILE: a/i.java +package a; + +public interface i { + public class O {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i { + public class O {} +} + +// FILE: a/i3.java +package a; + +public interface i3 extends i2 {} + +// FILE: a/test.java +package a; + +public class test extends x2 implements i3 { + public O getO() { return null; } +} + +// FILE: test.kt +package a + +fun test1() = test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt new file mode 100644 index 00000000000..88e59eb2cfa --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt @@ -0,0 +1,73 @@ +package + +package a { + public fun test1(): a.i2.O! + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 : a.i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i3 : a.i2 { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class test : a.x2, a.i3 { + public constructor test() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getO(): a.i2.O! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + private open inner class O { + private constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class x1 : a.x { + public constructor x1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x2 : a.x1 { + public constructor x2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt new file mode 100644 index 00000000000..893a71a7977 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt @@ -0,0 +1,49 @@ +// FILE: a/x.java +package a; + +public class x { + class O {} +} + +// FILE: a/x1.java +package a; + +public class x1 extends x {} + +// FILE: a/x2.java +package a; + +public class x2 extends x1 {} + +// FILE: a/i.java +package a; + +public interface i { + public class O {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i { + public class O {} +} + +// FILE: a/i3.java +package a; + +public interface i3 extends i2 {} + +// FILE: b/test.java +package b; + +import a.*; + +public class test extends x2 implements i3 { + public O getO() { return null; } +} + +// FILE: test.kt +package b + +fun test1() = test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt new file mode 100644 index 00000000000..c46930883bf --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt @@ -0,0 +1,76 @@ +package + +package a { + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 : a.i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i3 : a.i2 { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public/*package*/ open inner class O { + public/*package*/ constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class x1 : a.x { + public constructor x1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x2 : a.x1 { + public constructor x2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package b { + public fun test1(): a.i2.O! + + public open class test : a.x2, a.i3 { + public constructor test() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getO(): a.i2.O! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt b/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt new file mode 100644 index 00000000000..2444c7eedda --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt @@ -0,0 +1,33 @@ +// FILE: a/x.java +package a; + +public class x { + + public class y {} + +} + +// FILE: a/b.java +package a; + +public class b extends x { + + public class y {} + +} + +// FILE: a/c.java +package a; + +public class c extends b { + + public y getY() { return null; } + +} + +// FILE: test.kt +package test + +import a.c + +fun test() = c().getY() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt b/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt new file mode 100644 index 00000000000..b13fa5e4441 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt @@ -0,0 +1,44 @@ +package + +package a { + + public open class b : a.x { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class c : a.b { + public constructor c() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getY(): a.b.y! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): a.b.y! +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt b/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt new file mode 100644 index 00000000000..51ca4dd9846 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt @@ -0,0 +1,34 @@ +// FILE: a/x.java +package a; + +public class x { + public class O {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i { + public class Z {} +} + +// FILE: a/test.java +package a; + +public class test extends x implements i2 { + public Z getZ() { return null; } + public O getO() { return null; } +} + +// FILE: test.kt +package a + +fun test1() = test().getZ() +fun test2() = test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.txt b/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.txt new file mode 100644 index 00000000000..af6eff9fa0f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.txt @@ -0,0 +1,55 @@ +package + +package a { + public fun test1(): a.i2.Z! + public fun test2(): a.x.O! + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 : a.i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Z { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class test : a.x, a.i2 { + public constructor test() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getO(): a.x.O! + public open fun getZ(): a.i2.Z! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt b/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt new file mode 100644 index 00000000000..4059266cb47 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt @@ -0,0 +1,22 @@ +// FILE: a/Parent.java +package a; + +public interface Parent { + public class Foo {} +} + +// FILE: a/Outer.java +package a; + +public class Outer { + public class Inner implements Parent { + public Foo bar() { + return null; + } + } +} + +// FILE: test.kt +package a + +fun test() = Outer().Inner().bar() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt b/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt new file mode 100644 index 00000000000..00410fa091d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt @@ -0,0 +1,33 @@ +package + +package a { + public fun test(): a.Parent.Foo! + + public open class Outer { + public constructor Outer() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Inner /*captured type parameters: /*0*/ Foo : kotlin.Any!*/ : a.Parent { + public constructor Inner() + public open fun bar(): a.Parent.Foo! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface Parent { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Foo { + public constructor Foo() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt new file mode 100644 index 00000000000..7797c67bc23 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt @@ -0,0 +1,38 @@ +// FILE: p1/I.java +package p1; + +public interface I {} + +// FILE: p2/I.java +package p2; + +public class I {} + +// FILE: p/X.java +package p; + +import p1.*; +import p2.I; + +public class X { + + public class I1 { + public I getI() { return null; } + } + + public static class N { + public I getI() { return null; } + + public class I { + public I getI() { return null; } + } + + } + + public class I { + public I getI() { return null; } + } + + public I getI() { return null; } + +} \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.txt b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.txt new file mode 100644 index 00000000000..d66068ed8c5 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.txt @@ -0,0 +1,63 @@ +package + +package p { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): p.X.I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class I { + public constructor I() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): p.X.I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open inner class I1 { + public constructor I1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class N { + public constructor N() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): p.X.N.I<(raw) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class I { + public constructor I() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} + +package p1 { + + public interface I { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package p2 { + + public open class I { + public constructor I() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt new file mode 100644 index 00000000000..e171cadbf85 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt @@ -0,0 +1,41 @@ +// FILE: p1/I.java +package p1; + +public interface I {} + +// FILE: p2/I.java +package p2; + +public class I {} + +// FILE: p/X.java +package p; + +import p1.*; +import p2.I; + +public class X { + + public class I1 { + public I getI() { return null; } + } + + public class N { + public I getI() { return null; } + + public class I {} + + private class M { + public I getI() { return null; } + public I1 getI1() { return null; } + + class I1 { + I1 getI1() { return null; } + } + } + + } + + public I getI() { return null; } + +} \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.txt b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.txt new file mode 100644 index 00000000000..4633eb334ad --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.txt @@ -0,0 +1,71 @@ +package + +package p { + + public open class X { + public constructor X() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): p2.I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class I1 { + public constructor I1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open inner class N { + public constructor N() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): p.X.N.I! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class I { + public constructor I() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + private open inner class M { + private constructor M() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open fun getI1(): I1! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public/*package*/ open inner class I1 /*captured type parameters: /*0*/ I : kotlin.Any!, /*1*/ I1 : kotlin.Any!*/ { + public/*package*/ constructor I1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open fun getI1(): p.X.N.M.I1! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } + } +} + +package p1 { + + public interface I { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package p2 { + + public open class I { + public constructor I() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt b/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt new file mode 100644 index 00000000000..fc053745609 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt @@ -0,0 +1,25 @@ +// FILE: a/x.java +package a; + +public class x { + + public b getB() { return null; } + + public class b { + public b getB() { return null; } + } + +} + +// FILE: a/b.java +package a; + +public class b {} + +// FILE: test/test.kt +package test + +import a.x + +fun test() = x().getB() +fun test2() = test().getB() diff --git a/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.txt b/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.txt new file mode 100644 index 00000000000..983e5f53cbd --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.txt @@ -0,0 +1,32 @@ +package + +package a { + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): a.x.b! + public fun test2(): a.x.b! +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt b/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt new file mode 100644 index 00000000000..ca333bf3ff4 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt @@ -0,0 +1,48 @@ +// FILE: a/x.java +package a; + +public class x { + + public b getB() { return null; } + + public static class b { + + public b getB() { return null; } + + public static class b { + + public b getB() { return null; } + + public static class b { + public b getB() { return null; } + } + + } + + } + +} + +// FILE: b/x.java +package b; + +import a.x.b.b.b; + +public class x { + public b getB() { return null; } +} + +// FILE: b/y.java +package b; + +import a.x.b.b.*; + +public class y { + public b getB() { return null; } +} + +// FILE: b/test.kt +package b + +fun test() = x().getB() +fun test2() = y().getB() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.txt b/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.txt new file mode 100644 index 00000000000..69e9ec2a0c2 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.txt @@ -0,0 +1,57 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } + } +} + +package b { + public fun test(): a.x.b.b.b! + public fun test2(): a.x.b.b.b! + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class y { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt b/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt new file mode 100644 index 00000000000..358effd79c2 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt @@ -0,0 +1,27 @@ +// FILE: a/x.java +package a; + +public class x { + + public b getB() { return null; } + + public class b { + + public b getB() { return null; } + + public class b { + + public b getB() { return null; } + + } + + } + +} + +// FILE: test.kt +package a + +fun test() = x().getB() +fun test2() = test().getB() +fun test3() = test2().getB() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.txt b/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.txt new file mode 100644 index 00000000000..e2ececae134 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.txt @@ -0,0 +1,31 @@ +package + +package a { + public fun test(): a.x.b! + public fun test2(): a.x.b.b! + public fun test3(): a.x.b.b! + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/Nested.kt b/compiler/testData/javac/diagnostics/tests/inners/Nested.kt new file mode 100644 index 00000000000..1bb7bc143d4 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/Nested.kt @@ -0,0 +1,23 @@ +// FILE: p/p.kt; +package p + +object Object { + sealed class Sealed1 { + sealed class Sealed2 { + } + } +} + +// FILE: a/x.java +package a; + +import p.Object; + +public class x { + public Object.Sealed1.Sealed2 getSealed2() { return null; }; +} + +// FILE: test.kt +package a + +fun test() = x().getSealed2() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inners/Nested.txt b/compiler/testData/javac/diagnostics/tests/inners/Nested.txt new file mode 100644 index 00000000000..53795353575 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/Nested.txt @@ -0,0 +1,37 @@ +package + +package a { + public fun test(): p.Object.Sealed1.Sealed2! + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getSealed2(): p.Object.Sealed1.Sealed2! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package p { + + public object Object { + private constructor Object() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public sealed class Sealed1 { + private constructor Sealed1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public sealed class Sealed2 { + private constructor Sealed2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt b/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt new file mode 100644 index 00000000000..6b0867dd472 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt @@ -0,0 +1,32 @@ +// FILE: a/x.java +package a; + +public class x { + + public b getB() { return null; } + + public static class b { + + public b getB() { return null; } + + public static class b { + + public b getB() { return null; } + + public static class b { + public b getB() { return null; } + } + + } + + } + +} + +// FILE: test.kt +package a + +fun test() = x().getB() +fun test2() = test().getB() +fun test3() = test2().getB() +fun test4() = test3().getB() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.txt b/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.txt new file mode 100644 index 00000000000..7264c1abee3 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.txt @@ -0,0 +1,40 @@ +package + +package a { + public fun test(): a.x.b! + public fun test2(): a.x.b.b! + public fun test3(): a.x.b.b.b! + public fun test4(): a.x.b.b.b! + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.x.b.b.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt new file mode 100644 index 00000000000..abc49279f2f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt @@ -0,0 +1,55 @@ +// FILE: a/b/c.java +package a.b; + +public class c { + public void ab_c() {} +} + +// FILE: a/b.java +package a; + +public class b { + public static class c { + public void a_bc() {} + } +} + +// FILE: c/d.java +package c; + +import a.b.c; + +public class d { + + public c getC() { return null; } + +} + +// FILE: c.kt +import a.b.c +import c.d + +fun test(ab_c: c) { + ab_c.ab_c() + + val ab_c2: a.b.c = a.b.c() + ab_c2.ab_c() + + val ab_c3 = a.b.c() + ab_c3.ab_c() +} + +fun test2(ab_c: a.b.c) { + ab_c.a_bc() + ab_c.ab_c() +} + +fun test3() = d().getC() + +fun test4() { + val ab_c = test3() + ab_c.ab_c() + + val ab_c2 = test3() + ab_c2.a_bc() +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt new file mode 100644 index 00000000000..42fd2cfaf5a --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt @@ -0,0 +1,46 @@ +package + +public fun test(/*0*/ ab_c: a.b.c): kotlin.Unit +public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit +public fun test3(): a.b.c! +public fun test4(): kotlin.Unit + +package a { + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class c { + public constructor c() + public open fun a_bc(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + package a.b { + + public open class c { + public constructor c() + public open fun ab_c(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package c { + + public open class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getC(): a.b.c! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt new file mode 100644 index 00000000000..fbe0dbabe5b --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt @@ -0,0 +1,46 @@ +// FILE: a/b/c.java +package a.b; + +public class c { + public void ab_c() {} +} + +// FILE: a/b.java +package a; + +public class b { + public void a_b() {} + + public static class c { + public void a_bc() {} + } +} + +// FILE: d/d.java +package d; + +public class d { + + public a.b test() { return null; } + public a.b.c test2() { return null; } + +} + +// FILE: c.kt + +fun t() = d.d().test() +fun t2() = d.d().test2() + +fun test(a_b: a.b) { + a_b.a_b() + + val ab_c = t2() + ab_c.ab_c() + ab_c.a_bc() + + val ab_c2: a.b.c = t2() + ab_c2.ab_c() + ab_c2.a_bc() +} + +fun test2() = t().a_b() diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.txt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.txt new file mode 100644 index 00000000000..00d63185140 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.txt @@ -0,0 +1,48 @@ +package + +public fun t(): a.b! +public fun t2(): a.b.c! +public fun test(/*0*/ a_b: a.b): kotlin.Unit +public fun test2(): kotlin.Unit + +package a { + + public open class b { + public constructor b() + public open fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class c { + public constructor c() + public open fun a_bc(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + package a.b { + + public open class c { + public constructor c() + public open fun ab_c(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package d { + + public open class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): a.b! + public open fun test2(): a.b.c! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt new file mode 100644 index 00000000000..644b3031031 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt @@ -0,0 +1,47 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// FILE: a/a.java +package a; + +public class a {} + +// FILE: a/b.java +package a; + +public class b { + public void a_b() {} +} + +// FILE: test/a.java +package test; + +public class a {} + +// FILE: test/d.java +package test; + +public class d { + public a.b getB() { return null; } +} + +// FILE: b.kt +package test + +val x = d().getB() + +// FILE: test/c.java +package test; + +import a.a; + +public class c { + public static a getA() { return null; } +} + +// FILE: c.kt +package test + +fun foo() { + val a = c.getA() + a.a + a.a() +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt new file mode 100644 index 00000000000..a68b8485888 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt @@ -0,0 +1,49 @@ +package + +package a { + + public open class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class b { + public constructor b() + public open fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package test { + public val x: a.b! + public fun foo(): kotlin.Unit + + public open class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class c { + public constructor c() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + // Static members + public open fun getA(): a.a! + } + + public open class d { + public constructor d() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getB(): a.b! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt new file mode 100644 index 00000000000..1e69edf8855 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt @@ -0,0 +1,55 @@ +// FILE: a/b.java +package a; + +public class b { + public void a_b() {} +} + +// FILE: a.java +public class a { + public static class b { + public void _ab() {} + } +} + +// FILE: some/c1.java +package some; + +public class c1 { + public a.b test() { return null; } +} + + +// FILE: a/c2.java +package a; + +public class c2 { + public a.b test() { return null; } +} + +// FILE: c3.java +public class c3 { + public a.b test() { return null; } +} + +// FILE: c1.kt +package some + +fun test() { + val a_b = c1().test() + a_b.a_b() +} + +// FILE: c2.kt +package a + +fun test() { + val a_b = c2().test() + a_b.a_b() +} + +// FILE: c3.kt +fun test() { + val _ab = c3().test() + _ab._ab() +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt new file mode 100644 index 00000000000..f35b9bf0bdf --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt @@ -0,0 +1,58 @@ +package + +public fun test(): kotlin.Unit + +public open class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open fun _ab(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +public open class c3 { + public constructor c3() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): a.b! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +package a { + public fun test(): kotlin.Unit + + public open class b { + public constructor b() + public open fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class c2 { + public constructor c2() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): a.b! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package some { + public fun test(): kotlin.Unit + + public open class c1 { + public constructor c1() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun test(): a.b! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt new file mode 100644 index 00000000000..80b970a1f3f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt @@ -0,0 +1,57 @@ +// FILE: a/b.java +package a; + +public class b { + public void a_b() {} +} + +// FILE:some/a.java +package some; + +public class a { + public static class b { + public void some_ab() {} + } +} + +// FILE: c1.kt +package other + +class a {} + +fun test(a_: a.b) { + val a_2 = a.b() +} + +//FILE: c2.kt +package other2 + +class a { + class b { + fun other2_ab() {} + } +} + +fun test(_ab: a.b) { + _ab.other2_ab() + + val _ab2 = a.b() + _ab2.other2_ab() +} + +// FILE: c3.kt +package some + +fun test(_ab: a.b) { + _ab.some_ab() + + val _ab2 = a.b() + _ab2.some_ab() +} + +// FILE: c4.kt +package a + +fun test(_b: b) { + _b.a_b() +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt new file mode 100644 index 00000000000..b31ea49b02d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt @@ -0,0 +1,62 @@ +package + +package a { + public fun test(/*0*/ _b: a.b): kotlin.Unit + + public open class b { + public constructor b() + public open fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package other { + public fun test(/*0*/ a_: [ERROR : a.b]): kotlin.Unit + + public final class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + +package other2 { + public fun test(/*0*/ _ab: other2.a.b): kotlin.Unit + + public final class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final fun other2_ab(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package some { + public fun test(/*0*/ _ab: some.a.b): kotlin.Unit + + public open class a { + public constructor a() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class b { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open fun some_ab(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt new file mode 100644 index 00000000000..b98446aff82 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt @@ -0,0 +1,33 @@ +// FILE: a/x.java +package a; + +public class x { + public class O {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class O {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i { + public O getO(); +} + +// FILE: a/Test.java +package a; + +public class Test extends x implements i2 { + @Override + public O getO() { return null; } +} + +// FILE: test.kt +package a + +fun test() = Test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.txt new file mode 100644 index 00000000000..599cb5c51a4 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.txt @@ -0,0 +1,47 @@ +package + +package a { + public fun test(): O! + + public open class Test : a.x, a.i2 { + public constructor Test() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + @java.lang.Override public open override /*1*/ fun getO(): O! + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public interface i2 : a.i { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun getO(): a.i.O! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class O { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt new file mode 100644 index 00000000000..5284bcb203a --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt @@ -0,0 +1,51 @@ +// FILE: p/J.java +package p; + +public class J { + + public interface Z {} + + public class I {} + + public class T {} + +} + +// FILE: p/D.java +package p; + +public class D extends J { + + public Z getZ() { return null; } + public Z getZ2(Z z) { return z; } + public I getI() { return null; } + + public class Z { + public Z getZ() { return null; } + public I getI() { return null; } + } + + public class O { + public class Z {} + public Z getZ() { return null; } + public Z getZ2() { return null; } + } + + public class Test { + + public Z getZ() { return null; } + + public class Inner { + public Z getZ() { return null; } + public T getT() { return null; } + public I getI() { return null; } + } + + } + +} + +// FILE: test.kt +package p + +fun test() = D().getZ2(1) \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.txt new file mode 100644 index 00000000000..32ced9c855a --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.txt @@ -0,0 +1,85 @@ +package + +package p { + public fun test(): kotlin.Int! + + public open class D : p.J { + public constructor D() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): p.J.I! + public open fun getZ(): Z! + public open fun getZ2(/*0*/ z: Z!): Z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class O /*captured type parameters: /*0*/ Z : kotlin.Any!*/ { + public constructor O() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): p.D.O.Z! + public open fun getZ2(): Z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Z /*captured type parameters: /*0*/ Z : kotlin.Any!*/ { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open inner class Test /*captured type parameters: /*2*/ Z : kotlin.Any!*/ { + public constructor Test() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getZ(): Z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class Inner /*captured type parameters: /*2*/ Z : kotlin.Any!, /*3*/ T : kotlin.Any!, /*4*/ Z : kotlin.Any!*/ { + public constructor Inner() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open fun getT(): T! + public open fun getZ(): Z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open inner class Z /*captured type parameters: /*1*/ Z : kotlin.Any!*/ { + public constructor Z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open fun getZ(): p.D<(raw) kotlin.Any!, (raw) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + + public open class J { + public constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class I { + public constructor I() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open inner class T { + public constructor T() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public interface Z { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt new file mode 100644 index 00000000000..591d0e2fe8a --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt @@ -0,0 +1,20 @@ +// FILE: a/x.java +package a; + +public class x { + public class T {} +} + +// FILE: a/b.java +package a; + +public class b extends x { + public T getT() { return null; } +} + +// FILE: test.kt +package test + +import a.b + +fun test() = b().getT() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt new file mode 100644 index 00000000000..b11777c4c19 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt @@ -0,0 +1,30 @@ +package + +package a { + + public open class b : a.x { + public constructor b() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class T { + public constructor T() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): kotlin.String! +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt new file mode 100644 index 00000000000..9c396ebf5d1 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt @@ -0,0 +1,22 @@ +// FILE: a/x.java +package a; + +public class x { + + public T getT() { return null; } + + public class y { + public T getT() { return null; } + public Z getZ() { return null; } + } + +} + +// FILE: test.kt +package test + +import a.* + +fun test() = x().getT() +fun test2() = x().y().getT() +fun test3() = x().y().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.txt new file mode 100644 index 00000000000..e831acd2a7f --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.txt @@ -0,0 +1,27 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y /*captured type parameters: /*1*/ T : kotlin.Any!*/ { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): T! + public open fun getZ(): Z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): kotlin.String! + public fun test2(): kotlin.Int! + public fun test3(): kotlin.String! +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt new file mode 100644 index 00000000000..29546061f5d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt @@ -0,0 +1,25 @@ +// FILE: a/x.java +package a; + +public class x { + + public static class Nested { + + public T getT() { return null; } + + public class T { + + public T getT() { return null; } + + } + + } + +} + +// FILE: test.kt +package test + +import a.* + +fun test() = x.Nested().getT().getT() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.txt new file mode 100644 index 00000000000..3f580c9891d --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.txt @@ -0,0 +1,31 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open class Nested { + public constructor Nested() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): a.x.Nested.T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class T { + public constructor T() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): a.x.Nested.T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} + +package test { + public fun test(): a.x.Nested.T! +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt new file mode 100644 index 00000000000..762bcb1ee24 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt @@ -0,0 +1,22 @@ +// FILE: a/x.java +package a; + +public class x { + public class y { + public class z { + public T getT() { return null; } + public Z getZ() { return null; } + public I getI() { return null; } + } + } +} + +// FILE: test.kt +package test + +import a.* + +fun test() = x().y().z() +fun test2() = test().getT() +fun test3() = test().getZ() +fun test4() = test().getI() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.txt new file mode 100644 index 00000000000..6b6935d16fe --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.txt @@ -0,0 +1,35 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y /*captured type parameters: /*1*/ T : kotlin.Any!*/ { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class z /*captured type parameters: /*2*/ Z : kotlin.Any!, /*3*/ T : kotlin.Any!*/ { + public constructor z() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getI(): I! + public open fun getT(): T! + public open fun getZ(): Z! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } + } +} + +package test { + public fun test(): a.x.y.z + public fun test2(): kotlin.String! + public fun test3(): kotlin.Double! + public fun test4(): kotlin.Double! +} diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt b/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt new file mode 100644 index 00000000000..7a800a3de22 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt @@ -0,0 +1,20 @@ +// FILE: a/x.java +package a; + +public class x { + + public T getT() { return null; } + + public class y { + public T getT() { return null; } + } + +} + +// FILE: test.kt +package test + +import a.* + +fun test() = x().getT() +fun test2() = x().y().getT() diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt b/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt new file mode 100644 index 00000000000..f9cf8d6e6d0 --- /dev/null +++ b/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt @@ -0,0 +1,25 @@ +package + +package a { + + public open class x { + public constructor x() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public open inner class y /*captured type parameters: /*1*/ T : kotlin.Any!*/ { + public constructor y() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun getT(): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +package test { + public fun test(): kotlin.String! + public fun test2(): kotlin.String! +} diff --git a/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.java b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.java index c261c642065..fb1150d9d9f 100644 --- a/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.java +++ b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.java @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test; diff --git a/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.javac.txt b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.javac.txt new file mode 100644 index 00000000000..5f5942a03ef --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.javac.txt @@ -0,0 +1,53 @@ +package test + +public abstract class ClassDoesNotOverrideMethod : java.util.Date { + public constructor ClassDoesNotOverrideMethod() + invisible_fake final override /*1*/ /*fake_override*/ var cdate: sun.util.calendar.BaseCalendar.Date! + invisible_fake final override /*1*/ /*fake_override*/ var fastTime: kotlin.Long + public open override /*1*/ /*fake_override*/ fun after(/*0*/ p0: java.util.Date!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun before(/*0*/ p0: java.util.Date!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: java.util.Date!): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarDate(): sun.util.calendar.BaseCalendar.Date! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getDay(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getHours(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getMinutes(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getMonth(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getSeconds(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getTime(): kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ fun getTimeImpl(): kotlin.Long + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getTimezoneOffset(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getYear(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun normalize(): sun.util.calendar.BaseCalendar.Date! + invisible_fake final override /*1*/ /*fake_override*/ fun normalize(/*0*/ p0: sun.util.calendar.BaseCalendar.Date!): sun.util.calendar.BaseCalendar.Date! + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setMonth(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setSeconds(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setTime(/*0*/ p0: kotlin.Long): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun toGMTString(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toInstant(): java.time.Instant! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun toLocaleString(): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit + + // Static members + invisible_fake final override /*1*/ /*fake_override*/ var defaultCenturyStart: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ val gcal: sun.util.calendar.BaseCalendar! + invisible_fake final override /*1*/ /*fake_override*/ var jcal: sun.util.calendar.BaseCalendar! + invisible_fake const final override /*1*/ /*fake_override*/ val serialVersionUID: kotlin.Long = 7523967970034938905.toLong() + invisible_fake final override /*1*/ /*fake_override*/ val ttb: kotlin.IntArray! + invisible_fake final override /*1*/ /*fake_override*/ val wtb: kotlin.Array<(out) kotlin.String!>! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun UTC(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int, /*2*/ p2: kotlin.Int, /*3*/ p3: kotlin.Int, /*4*/ p4: kotlin.Int, /*5*/ p5: kotlin.Int): kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ fun convertToAbbr(/*0*/ p0: java.lang.StringBuilder!, /*1*/ p1: kotlin.String!): java.lang.StringBuilder! + public open override /*1*/ /*fake_override*/ fun from(/*0*/ p0: java.time.Instant!): java.util.Date! + invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarSystem(/*0*/ p0: kotlin.Int): sun.util.calendar.BaseCalendar! + invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarSystem(/*0*/ p0: kotlin.Long): sun.util.calendar.BaseCalendar! + invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarSystem(/*0*/ p0: sun.util.calendar.BaseCalendar.Date!): sun.util.calendar.BaseCalendar! + invisible_fake final override /*1*/ /*fake_override*/ fun getJulianCalendar(): sun.util.calendar.BaseCalendar! + invisible_fake final override /*1*/ /*fake_override*/ fun getMillisOf(/*0*/ p0: java.util.Date!): kotlin.Long + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun parse(/*0*/ p0: kotlin.String!): kotlin.Long +} diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.java b/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.java index 683540f1b32..e43de36ae75 100644 --- a/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.java +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.java @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test; diff --git a/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.javac.txt b/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.javac.txt new file mode 100644 index 00000000000..35822c7552b --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.javac.txt @@ -0,0 +1,8 @@ +package test + +public abstract class ClassWithTypePExtendsIterableP : kotlin.collections.MutableIterable { + public constructor ClassWithTypePExtendsIterableP() + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator +} diff --git a/compiler/testData/loadJava/compiledJava/TopLevel$Class.java b/compiler/testData/loadJava/compiledJava/TopLevel$Class.java index ded7a5e63df..a9694290655 100644 --- a/compiler/testData/loadJava/compiledJava/TopLevel$Class.java +++ b/compiler/testData/loadJava/compiledJava/TopLevel$Class.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; public class TopLevel$Class { diff --git a/compiler/testData/loadJava/compiledJava/TopLevel$Class.javac.txt b/compiler/testData/loadJava/compiledJava/TopLevel$Class.javac.txt new file mode 100644 index 00000000000..56e54040790 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/TopLevel$Class.javac.txt @@ -0,0 +1 @@ +package test diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java index 5bc48d85773..02ab223b2d7 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; import java.util.*; diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.javac.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.javac.txt new file mode 100644 index 00000000000..60f776f1a16 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.javac.txt @@ -0,0 +1,45 @@ +package test + +public interface HalfSubstitutedTypeParameters { + + public interface Sub : test.HalfSubstitutedTypeParameters.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit + public abstract override /*1*/ fun foo(): test.HalfSubstitutedTypeParameters.TrickyList! + } + + public interface Super { + public abstract fun dummy(): kotlin.Unit + public abstract fun foo(): kotlin.collections.(Mutable)List! + } + + public interface TrickyList : kotlin.collections.MutableList { + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: E!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: E!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: E!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): E! + public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: E!): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: E!): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public abstract override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: E!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAt(/*0*/ index: kotlin.Int): E! + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.UnaryOperator): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: E!): E! + public open override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ p0: java.util.Comparator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream + public abstract override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + } +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.java b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.java index d5e36c9d163..363de1ce59e 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.java +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; import java.util.*; diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.javac.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.javac.txt new file mode 100644 index 00000000000..d93f11b02d3 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.javac.txt @@ -0,0 +1,20 @@ +package test + +public interface SubclassOfCollection : kotlin.collections.MutableCollection { + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: E!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: E!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: E!): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream +} diff --git a/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.java b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.java index e2d8dd8cd30..58f1baf3bad 100644 --- a/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.java +++ b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.java @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test; import org.jetbrains.annotations.NotNull; diff --git a/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.javac.txt b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.javac.txt new file mode 100644 index 00000000000..96ddf0f1023 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.javac.txt @@ -0,0 +1,44 @@ +package test + +public open class ModalityOfFakeOverrides : java.util.AbstractList { + public constructor ModalityOfFakeOverrides() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public open override /*1*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + @org.jetbrains.annotations.NotNull public open override /*1*/ fun get(/*0*/ index: kotlin.Int): kotlin.String + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.UnaryOperator): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String! + public open override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ p0: java.util.Comparator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + + // Static members + invisible_fake const final override /*1*/ /*fake_override*/ val MAX_ARRAY_SIZE: kotlin.Int = 2147483639 + invisible_fake open override /*1*/ /*fake_override*/ fun finishToArray(/*0*/ p0: kotlin.Array<(out) T!>!, /*1*/ p1: kotlin.collections.(Mutable)Iterator<*>!): kotlin.Array<(out) T!>! + invisible_fake open override /*1*/ /*fake_override*/ fun hugeCapacity(/*0*/ p0: kotlin.Int): kotlin.Int +} diff --git a/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java index 0585609ad95..b3288066a5c 100644 --- a/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java +++ b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; import java.util.Comparator; diff --git a/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.javac.txt b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.javac.txt new file mode 100644 index 00000000000..4e7b4183f1c --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.javac.txt @@ -0,0 +1,12 @@ +package test + +public interface SubstitutedSamInterface : java.util.Comparator { + public abstract override /*1*/ /*fake_override*/ fun compare(/*0*/ p0: kotlin.String!, /*1*/ p1: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun reversed(): java.util.Comparator! + public open override /*1*/ /*fake_override*/ fun thenComparing(/*0*/ p0: java.util.Comparator!): java.util.Comparator! + public open override /*1*/ /*fake_override*/ fun !> thenComparing(/*0*/ p0: java.util.function.Function!): java.util.Comparator! + public open override /*1*/ /*fake_override*/ fun thenComparing(/*0*/ p0: java.util.function.Function!, /*1*/ p1: java.util.Comparator!): java.util.Comparator! + public open override /*1*/ /*fake_override*/ fun thenComparingDouble(/*0*/ p0: java.util.function.ToDoubleFunction!): java.util.Comparator! + public open override /*1*/ /*fake_override*/ fun thenComparingInt(/*0*/ p0: java.util.function.ToIntFunction!): java.util.Comparator! + public open override /*1*/ /*fake_override*/ fun thenComparingLong(/*0*/ p0: java.util.function.ToLongFunction!): java.util.Comparator! +} diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.javac.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.javac.txt new file mode 100644 index 00000000000..5fdc30fd6e1 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.javac.txt @@ -0,0 +1,36 @@ +package test + +public abstract class ClassDoesNotOverrideMethod : java.util.Date { + /*primary*/ public constructor ClassDoesNotOverrideMethod() + invisible_fake final override /*1*/ /*fake_override*/ var cdate: sun.util.calendar.BaseCalendar.Date! + invisible_fake final override /*1*/ /*fake_override*/ var fastTime: kotlin.Long + public open override /*1*/ /*fake_override*/ fun after(/*0*/ p0: java.util.Date!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun before(/*0*/ p0: java.util.Date!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: java.util.Date!): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun getCalendarDate(): sun.util.calendar.BaseCalendar.Date! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getDate(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getDay(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getHours(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getMinutes(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getMonth(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getSeconds(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun getTime(): kotlin.Long + invisible_fake final override /*1*/ /*fake_override*/ fun getTimeImpl(): kotlin.Long + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getTimezoneOffset(): kotlin.Int + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun getYear(): kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ fun normalize(): sun.util.calendar.BaseCalendar.Date! + invisible_fake final override /*1*/ /*fake_override*/ fun normalize(/*0*/ p0: sun.util.calendar.BaseCalendar.Date!): sun.util.calendar.BaseCalendar.Date! + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setDate(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setHours(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setMinutes(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setMonth(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setSeconds(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun setTime(/*0*/ p0: kotlin.Long): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun setYear(/*0*/ p0: kotlin.Int): kotlin.Unit + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun toGMTString(): kotlin.String! + public open override /*1*/ /*fake_override*/ fun toInstant(): java.time.Instant! + @kotlin.Deprecated(message = "Deprecated in Java") public open override /*1*/ /*fake_override*/ fun toLocaleString(): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.kt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.kt index a4efb2d6954..4e7c73b4d84 100644 --- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.kt +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.kt @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.javac.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.javac.txt new file mode 100644 index 00000000000..3a1df4faa2b --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.javac.txt @@ -0,0 +1,8 @@ +package test + +public abstract class ClassWithTypePExtendsIterableP : kotlin.collections.MutableIterable

{ + /*primary*/ public constructor ClassWithTypePExtendsIterableP() + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator

+ public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator

+} diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.kt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.kt index e3e05080f94..24e418d3436 100644 --- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.kt +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.kt @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.javac.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.javac.txt new file mode 100644 index 00000000000..5b5f8463033 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.javac.txt @@ -0,0 +1,46 @@ +package test + +public interface HalfSubstitutedTypeParameters { + + public interface Sub : test.HalfSubstitutedTypeParameters.Super { + public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit + public abstract override /*1*/ fun foo(): test.HalfSubstitutedTypeParameters.TrickyList + } + + public interface Super { + public abstract fun dummy(): kotlin.Unit + public abstract fun foo(): kotlin.collections.MutableList + } + + public interface TrickyList : kotlin.collections.MutableList { + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun (): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: E): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: E): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: E): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): E + public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: E): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: E): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public abstract override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: E): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAt(/*0*/ index: kotlin.Int): E + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.UnaryOperator): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: E): E + public open override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ p0: java.util.Comparator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream + public abstract override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + } +} diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt index 15ed2dc5e7d..5b93f60a69b 100644 --- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.javac.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.javac.txt new file mode 100644 index 00000000000..259f6a5f853 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.javac.txt @@ -0,0 +1,21 @@ +package test + +public interface SubclassOfCollection : kotlin.collections.MutableCollection { + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun (): kotlin.Int + public abstract override /*1*/ /*fake_override*/ fun add(/*0*/ element: E): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ element: E): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public abstract override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public abstract override /*1*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + public abstract override /*1*/ /*fake_override*/ fun remove(/*0*/ element: E): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream +} diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt index b7fad065d15..d0d00c75341 100644 --- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.javac.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.javac.txt new file mode 100644 index 00000000000..14b48930c98 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.javac.txt @@ -0,0 +1,40 @@ +package test + +public open class ModalityOfFakeOverrides : java.util.AbstractList { + /*primary*/ public constructor ModalityOfFakeOverrides() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public open override /*1*/ val size: kotlin.Int + public open override /*1*/ fun (): kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ fun get(/*0*/ index: kotlin.Int): kotlin.String + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.UnaryOperator): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String!): kotlin.String! + public open override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ p0: java.util.Comparator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! +} diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.kt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.kt index 29df4ec2c61..107d6e16d36 100644 --- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.kt +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.kt @@ -1,4 +1,6 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE + package test import java.util.AbstractList diff --git a/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.javac.txt b/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.javac.txt new file mode 100644 index 00000000000..5f0b44413c5 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.javac.txt @@ -0,0 +1,54 @@ +package test + +public final class C : java.util.ArrayList { + /*primary*/ public constructor C() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun (): kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.UnaryOperator): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String): kotlin.String + public open override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ p0: java.util.Comparator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.kt b/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.kt index 66b057946e8..1947b33c2db 100644 --- a/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.kt +++ b/compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.kt @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test class C: java.util.ArrayList() diff --git a/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.javac.txt b/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.javac.txt new file mode 100644 index 00000000000..8acfdfea942 --- /dev/null +++ b/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.javac.txt @@ -0,0 +1,54 @@ +package test + +public final class C : java.util.ArrayList { + /*primary*/ public constructor C() + invisible_fake final override /*1*/ /*fake_override*/ var elementData: kotlin.Array<(out) kotlin.Any!>! + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + invisible_fake final override /*1*/ /*fake_override*/ var size: kotlin.Int + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun (): kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String?): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.String?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun batchRemove(/*0*/ p0: kotlin.collections.(Mutable)Collection<*>!, /*1*/ p1: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.String?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + invisible_fake open override /*1*/ /*fake_override*/ fun elementData(/*0*/ p0: kotlin.Int): kotlin.String? + public open override /*1*/ /*fake_override*/ fun ensureCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureCapacityInternal(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun ensureExplicitCapacity(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun fastRemove(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun forEach(/*0*/ p0: java.util.function.Consumer!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.String? + invisible_fake open override /*1*/ /*fake_override*/ fun grow(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.String?): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.String?): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + public open override /*1*/ /*fake_override*/ fun parallelStream(): java.util.stream.Stream + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheck(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: kotlin.String?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAt(/*0*/ p0: kotlin.Int): kotlin.String? + public open override /*1*/ /*fake_override*/ fun removeIf(/*0*/ p0: java.util.function.Predicate): kotlin.Boolean + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun replaceAll(/*0*/ p0: java.util.function.UnaryOperator): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.String?): kotlin.String? + public open override /*1*/ /*fake_override*/ /*isHiddenForResolutionEverywhereBesideSupercalls*/ fun sort(/*0*/ p0: java.util.Comparator!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun spliterator(): java.util.Spliterator + public open override /*1*/ /*fake_override*/ fun stream(): java.util.stream.Stream + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun trimToSize(): kotlin.Unit + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.kt b/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.kt index 285ff687053..c20e5f40877 100644 --- a/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.kt +++ b/compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.kt @@ -1,4 +1,5 @@ // FULL_JDK +// JAVAC_EXPECTED_FILE package test class C: java.util.ArrayList() diff --git a/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java b/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java index 003cb566f03..837e73838a2 100644 --- a/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java +++ b/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; public interface WrongNumberOfGenericParameters { diff --git a/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.javac.txt b/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.javac.txt new file mode 100644 index 00000000000..f3c9e00270f --- /dev/null +++ b/compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.javac.txt @@ -0,0 +1,17 @@ +package test + +public interface WrongNumberOfGenericParameters { + public abstract fun o0(): test.WrongNumberOfGenericParameters.One<(raw) kotlin.Any!>! + public abstract fun o2(): test.WrongNumberOfGenericParameters.One<(raw) kotlin.Any!>! + public abstract fun t1(): test.WrongNumberOfGenericParameters.Two<(raw) kotlin.Any!, (raw) kotlin.Any!>! + public abstract fun z(): test.WrongNumberOfGenericParameters.Zero! + + public interface One { + } + + public interface Two { + } + + public interface Zero { + } +} diff --git a/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java b/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java index f3f3a967e49..0b9078dcbf8 100644 --- a/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java +++ b/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; // SKIP_IN_RUNTIME_TEST diff --git a/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.javac.txt b/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.javac.txt new file mode 100644 index 00000000000..88a9361ce8d --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.javac.txt @@ -0,0 +1,13 @@ +package test + +public open class InnerClassTypeAnnotation { + public constructor InnerClassTypeAnnotation() + + @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class Foo : kotlin.Annotation { + public constructor Foo() + } + + public open inner class Inner { + public constructor Inner(/*0*/ p0: kotlin.String!) + } +} diff --git a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java b/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java index 304375846db..55dbc0b0bd1 100644 --- a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java +++ b/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java @@ -1,3 +1,4 @@ +// JAVAC_EXPECTED_FILE package test; import java.lang.annotation.*; diff --git a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt b/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt new file mode 100644 index 00000000000..e78e8750b0b --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt @@ -0,0 +1,14 @@ +package test + +public open class TypeParameterAnnotations { + public constructor TypeParameterAnnotations() + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { + public constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String + } + + public interface G { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + } +} diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt b/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt index 50f6e7b784a..2b279c7679a 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt @@ -23,10 +23,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.analyzer.common.DefaultAnalyzerFacade import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM -import org.jetbrains.kotlin.config.JvmTarget -import org.jetbrains.kotlin.config.LanguageVersionSettings -import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl -import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.context.SimpleGlobalContext @@ -72,6 +69,7 @@ import org.junit.Assert import java.io.File import java.util.* import java.util.function.Predicate +import java.util.regex.Pattern abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { override fun analyzeAndCheck(testDataFile: File, files: List) { @@ -144,7 +142,12 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { var exceptionFromDescriptorValidation: Throwable? = null try { - val expectedFile = File(FileUtil.getNameWithoutExtension(testDataFile.absolutePath) + ".txt") + val expectedFile = if (InTextDirectivesUtils.isDirectiveDefined(testDataFile.readText(), "// JAVAC_EXPECTED_FILE") + && environment.configuration.getBoolean(JVMConfigurationKeys.USE_JAVAC)) { + File(FileUtil.getNameWithoutExtension(testDataFile.absolutePath) + ".javac.txt") + } else { + File(FileUtil.getNameWithoutExtension(testDataFile.absolutePath) + ".txt") + } validateAndCompareDescriptorWithFile(expectedFile, files, modules) } catch (e: Throwable) { @@ -308,6 +311,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { val moduleContentScope = GlobalSearchScope.allScope(moduleContext.project) val moduleClassResolver = SingleModuleClassResolver() + val container = createContainerForTopDownAnalyzerForJvm( moduleContext, moduleTrace, @@ -319,6 +323,7 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { JvmTarget.JVM_1_6, languageVersionSettings ) + container.initJvmBuiltInsForTopDownAnalysis() moduleClassResolver.resolver = container.get() @@ -419,13 +424,34 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { KotlinTestUtils.assertEqualsToFile(expectedFile, allPackagesText) } + protected open fun skipDescriptorsValidation(): Boolean = false + private fun getJavaFilePackage(testFile: TestFile): Name { + val pattern = Pattern.compile("^\\s*package [.\\w\\d]*", Pattern.MULTILINE) + val matcher = pattern.matcher(testFile.expectedText) + + if (matcher.find()) { + return testFile.expectedText + .substring(matcher.start(), matcher.end()) + .split(" ") + .last() + .filter { !it.isWhitespace() } + .let { Name.identifier(it.split(".").first()) } + } + + return SpecialNames.ROOT_PACKAGE + } + private fun createdAffectedPackagesConfiguration( testFiles: List, modules: Collection ): RecursiveDescriptorComparator.Configuration { - val packagesNames = getTopLevelPackagesFromFileList(getKtFiles(testFiles, false)) + val packagesNames = ( + testFiles.filter { it.ktFile == null } + .map { getJavaFilePackage(it) } + + getTopLevelPackagesFromFileList(getKtFiles(testFiles, false)) + ).toSet() val stepIntoFilter = Predicate { descriptor -> val module = DescriptorUtils.getContainingModuleOrNull(descriptor) diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt b/compiler/tests-common/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt index acd4932bb1b..1a738e9b079 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt @@ -278,7 +278,7 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava extends KtUsefulTestCase protected void doTest(String filePath) throws Exception { File file = new File(filePath); - String expectedText = KotlinTestUtils.doLoadFile(file); - Map modules = new HashMap<>(); - - List testFiles = - KotlinTestUtils.createTestFiles(file.getName(), expectedText, new KotlinTestUtils.TestFileFactory() { - @Override - public F createFile( - @Nullable M module, - @NotNull String fileName, - @NotNull String text, - @NotNull Map directives - ) { - if (fileName.endsWith(".java")) { - writeSourceFile(fileName, text, javaFilesDir); - } - - if (fileName.endsWith(".kt") && kotlinSourceRoot != null) { - writeSourceFile(fileName, text, kotlinSourceRoot); - } - - return createTestFile(module, fileName, text, directives); - } - - @Override - public M createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends) { - M module = createTestModule(name); - ModuleAndDependencies oldValue = modules.put(name, new ModuleAndDependencies(module, dependencies, friends)); - assert oldValue == null : "Module " + name + " declared more than once"; - - return module; - } - - private void writeSourceFile(@NotNull String fileName, @NotNull String content, @NotNull File targetDir) { - File file = new File(targetDir, fileName); - KotlinTestUtils.mkdirs(file.getParentFile()); - FilesKt.writeText(file, content, Charsets.UTF_8); - } - }); + List testFiles = createTestFiles(file, expectedText, modules); doMultiFileTest(file, modules, testFiles); } @@ -180,4 +143,42 @@ public abstract class KotlinMultiFileTestWithJava extends KtUsefulTestCase protected abstract F createTestFile(M module, String fileName, String text, Map directives); protected abstract void doMultiFileTest(File file, Map modules, List files) throws Exception; + + protected List createTestFiles(File file, String expectedText, Map modules) { + return KotlinTestUtils.createTestFiles(file.getName(), expectedText, new KotlinTestUtils.TestFileFactory() { + @Override + public F createFile( + @Nullable M module, + @NotNull String fileName, + @NotNull String text, + @NotNull Map directives + ) { + if (fileName.endsWith(".java")) { + writeSourceFile(fileName, text, javaFilesDir); + } + + if (fileName.endsWith(".kt") && kotlinSourceRoot != null) { + writeSourceFile(fileName, text, kotlinSourceRoot); + } + + return createTestFile(module, fileName, text, directives); + } + + @Override + public M createModule(@NotNull String name, @NotNull List dependencies, @NotNull List friends) { + M module = createTestModule(name); + ModuleAndDependencies oldValue = modules.put(name, new ModuleAndDependencies(module, dependencies, friends)); + assert oldValue == null : "Module " + name + " declared more than once"; + + return module; + } + + private void writeSourceFile(@NotNull String fileName, @NotNull String content, @NotNull File targetDir) { + File file = new File(targetDir, fileName); + KotlinTestUtils.mkdirs(file.getParentFile()); + FilesKt.writeText(file, content, Charsets.UTF_8); + } + }); + } + } diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt b/compiler/tests-common/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt new file mode 100644 index 00000000000..00f02780a38 --- /dev/null +++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsUsingJavacTest.kt @@ -0,0 +1,48 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac + +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.utils.PathUtil +import java.io.File + +abstract class AbstractDiagnosticsUsingJavacTest : AbstractDiagnosticsTest() { + + override fun analyzeAndCheck(testDataFile: File, files: List) { + if (InTextDirectivesUtils.isDirectiveDefined(testDataFile.readText(), "// JAVAC_SKIP")) { + println("${testDataFile.name} test is skipped") + return + } + val groupedByModule = files.groupBy(TestFile::module) + val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } + val mockJdk = listOf(File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar")) + + environment.registerJavac(kotlinFiles = allKtFiles, bootClasspath = mockJdk) + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + super.analyzeAndCheck(testDataFile, files) + } + + private fun getHomeDirectory(): String { + val resourceRoot = PathUtil.getResourcePathForClass(KotlinTestUtils::class.java) + return FileUtil.toSystemIndependentName(resourceRoot.parentFile.parentFile.parent) + } + +} \ No newline at end of file diff --git a/compiler/tests-common/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt b/compiler/tests-common/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt new file mode 100644 index 00000000000..4780506fa71 --- /dev/null +++ b/compiler/tests-common/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac + +import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import java.io.File + +abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() { + + private var useJavac = true + + override fun analyzeAndCheck(testDataFile: File, files: List) { + if (useJavac) { + val groupedByModule = files.groupBy(TestFile::module) + val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } + environment.registerJavac(kotlinFiles = allKtFiles) + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + } + super.analyzeAndCheck(testDataFile, files) + } + + fun doTestWithoutJavacWrapper(path: String) { + useJavac = false + super.doTest(path) + } + +} + diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 7c39ca1253b..dc817b1e730 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -38,10 +38,7 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor; -import org.jetbrains.kotlin.test.ConfigurationKind; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestCaseWithTmpdir; -import org.jetbrains.kotlin.test.TestJdkKind; +import org.jetbrains.kotlin.test.*; import org.jetbrains.kotlin.test.util.DescriptorValidator; import org.junit.Assert; @@ -75,9 +72,13 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { File expectedFile = new File(expectedFileName); File sourcesDir = new File(expectedFileName.replaceFirst("\\.txt$", "")); + if (useJavacWrapper()) return; + List kotlinSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.kt"), sourcesDir); KotlinCoreEnvironment environment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY); + registerJavacIfNeeded(environment); + compileKotlinToDirAndGetModule(kotlinSources, tmpdir, environment); List javaSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.java"), sourcesDir); @@ -113,7 +114,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { @NotNull String ktFileName, @NotNull ConfigurationKind configurationKind, boolean useTypeTableInSerializer ) throws Exception { File ktFile = new File(ktFileName); - File txtFile = new File(ktFileName.replaceFirst("\\.kt$", ".txt")); + File txtFile = getTxtFileFromKtFile(ktFileName); CompilerConfiguration configuration = newConfiguration(configurationKind, TestJdkKind.MOCK_JDK, getAnnotationsJar()); if (useTypeTableInSerializer) { @@ -121,13 +122,14 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { } KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); + registerJavacIfNeeded(environment); ModuleDescriptor module = compileKotlinToDirAndGetModule(Collections.singletonList(ktFile), tmpdir, environment); PackageViewDescriptor packageFromSource = module.getPackage(TEST_PACKAGE_FQNAME); Assert.assertEquals("test", packageFromSource.getName().asString()); PackageViewDescriptor packageFromBinary = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot( - tmpdir, getTestRootDisposable(), getJdkKind(), configurationKind, true, false + tmpdir, getTestRootDisposable(), getJdkKind(), configurationKind, true, false, useJavacWrapper() ).first; for (DeclarationDescriptor descriptor : DescriptorUtils.getAllDescriptors(packageFromBinary.getMemberScope())) { @@ -146,6 +148,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { return false; } + protected boolean useJavacWrapper() { return false; } + + protected void registerJavacIfNeeded(KotlinCoreEnvironment environment) {} + protected void doTestJavaAgainstKotlin(String expectedFileName) throws Exception { File expectedFile = new File(expectedFileName); File sourcesDir = new File(expectedFileName.replaceFirst("\\.txt$", "")); @@ -159,7 +165,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); - + registerJavacIfNeeded(environment); AnalysisResult result = TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( environment.getProject(), environment.getSourceFiles(), new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), configuration, environment::createPackagePartProvider @@ -189,7 +195,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { newConfiguration(ConfigurationKind.JDK_ONLY, getJdkKind(), getAnnotationsJar(), libraryOut), EnvironmentConfigFiles.JVM_CONFIG_FILES ); - + registerJavacIfNeeded(environment); KtFile ktFile = KotlinTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); ModuleDescriptor module = JvmResolveUtil.analyzeAndCheckForErrors(Collections.singleton(ktFile), environment).getModuleDescriptor(); @@ -216,7 +222,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { Pair javaPackageAndContext = loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), getJdkKind(), ConfigurationKind.JDK_ONLY, false, - false); + false, useJavacWrapper()); checkJavaPackage( expectedFile, javaPackageAndContext.first, javaPackageAndContext.second, @@ -251,7 +257,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { srcFiles, compiledDir, ConfigurationKind.ALL ); - checkJavaPackage(getExpectedFile(javaFileName.replaceFirst("\\.java$", ".txt")), javaPackageAndContext.first, javaPackageAndContext.second, configuration); + checkJavaPackage(getTxtFile(javaFileName), javaPackageAndContext.first, javaPackageAndContext.second, configuration); } @NotNull @@ -262,7 +268,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { ) throws IOException { compileJavaWithAnnotationsJar(javaFiles, outDir); return loadTestPackageAndBindingContextFromJavaRoot(outDir, myTestRootDisposable, getJdkKind(), configurationKind, true, - useFastClassFilesReading()); + useFastClassFilesReading(), useJavacWrapper()); } private static void checkJavaPackage( @@ -295,6 +301,29 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { } private static File getTxtFile(String javaFileName) { - return new File(javaFileName.replaceFirst("\\.java$", ".txt")); + try { + String fileText = FileUtil.loadFile(new File(javaFileName)); + if (InTextDirectivesUtils.isDirectiveDefined(fileText, "// JAVAC_EXPECTED_FILE")) { + return new File(javaFileName.replaceFirst("\\.java$", ".javac.txt")); + } + else return new File(javaFileName.replaceFirst("\\.java$", ".txt")); + } + catch (IOException e) { + return new File(javaFileName.replaceFirst("\\.java$", ".txt")); + } } + + private static File getTxtFileFromKtFile(String ktFileName) { + try { + String fileText = FileUtil.loadFile(new File(ktFileName)); + if (InTextDirectivesUtils.isDirectiveDefined(fileText, "// JAVAC_EXPECTED_FILE")) { + return new File(ktFileName.replaceFirst("\\.kt$", ".javac.txt")); + } + else return new File(ktFileName.replaceFirst("\\.kt$", ".txt")); + } + catch (IOException e) { + return new File(ktFileName.replaceFirst("\\.kt$", ".txt")); + } + } + } diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index 203de647d77..9978079443a 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java @@ -32,6 +32,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.descriptors.PackageViewDescriptor; +import org.jetbrains.kotlin.jvm.compiler.javac.JavacRegistrarForTests; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.KtFile; @@ -72,7 +73,8 @@ public class LoadDescriptorUtil { @NotNull TestJdkKind testJdkKind, @NotNull ConfigurationKind configurationKind, boolean isBinaryRoot, - boolean useFastClassReading + boolean useFastClassReading, + boolean useJavacWrapper ) { List javaBinaryRoots = new ArrayList<>(); javaBinaryRoots.add(KotlinTestUtils.getAnnotationsJar()); @@ -88,9 +90,12 @@ public class LoadDescriptorUtil { CompilerConfiguration configuration = KotlinTestUtils.newConfiguration(configurationKind, testJdkKind, javaBinaryRoots, javaSourceRoots); configuration.put(JVMConfigurationKeys.USE_FAST_CLASS_FILES_READING, useFastClassReading); + configuration.put(JVMConfigurationKeys.USE_JAVAC, useJavacWrapper); KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); - + if (useJavacWrapper) { + JavacRegistrarForTests.INSTANCE.registerJavac(environment); + } AnalysisResult analysisResult = JvmResolveUtil.analyze(environment); PackageViewDescriptor packageView = analysisResult.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/javac/AbstractLoadJavaUsingJavacTest.kt b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/javac/AbstractLoadJavaUsingJavacTest.kt new file mode 100644 index 00000000000..c9c840c09ef --- /dev/null +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/compiler/javac/AbstractLoadJavaUsingJavacTest.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jvm.compiler.javac + +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJavaTest + +abstract class AbstractLoadJavaUsingJavacTest : AbstractLoadJavaTest() { + override fun registerJavacIfNeeded(environment: KotlinCoreEnvironment) { + environment.registerJavac() + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + } + + override fun useJavacWrapper() = true + +} + +object JavacRegistrarForTests { + fun registerJavac(environment: KotlinCoreEnvironment) { + environment.registerJavac() + } +} \ No newline at end of file diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt index 5577e037321..2b3cca31e2b 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -105,7 +105,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { } val expected = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot( - tmpdir, testRootDisposable, jdkKind, ConfigurationKind.ALL, true, false + tmpdir, testRootDisposable, jdkKind, ConfigurationKind.ALL, true, false, false ).first RecursiveDescriptorComparator.validateAndCompareDescriptors(expected, actual, comparatorConfiguration, null) diff --git a/compiler/tests-common/tests-common.iml b/compiler/tests-common/tests-common.iml index 97ee6b655b8..95246f4e2f4 100644 --- a/compiler/tests-common/tests-common.iml +++ b/compiler/tests-common/tests-common.iml @@ -32,5 +32,6 @@ + \ No newline at end of file diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java new file mode 100644 index 00000000000..20436052572 --- /dev/null +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java @@ -0,0 +1,95 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac; + +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/foreignAnnotationsJava8/tests") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacForeignJava8AnnotationsTest { + public void testAllFilesPresentInTests() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("checkerFramework.kt") + public void testCheckerFramework() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt"); + doTest(fileName); + } + + @TestMetadata("eclipse.kt") + public void testEclipse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt"); + doTest(fileName); + } + + @TestMetadata("springNullableWithTypeUse.kt") + public void testSpringNullableWithTypeUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/springNullableWithTypeUse.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancement extends AbstractJavacForeignJava8AnnotationsTest { + public void testAllFilesPresentInTypeEnhancement() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotatedTypeArguments.kt") + public void testAnnotatedTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("methodWithTypeParameter.kt") + public void testMethodWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeDifferentConstructor.kt") + public void testReturnTypeDifferentConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeOverrideInKotlin.kt") + public void testReturnTypeOverrideInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); + doTest(fileName); + } + } +} diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/AbstractLoadJava8UsingJavacTest.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/AbstractLoadJava8UsingJavacTest.kt new file mode 100644 index 00000000000..318b27342ad --- /dev/null +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/AbstractLoadJava8UsingJavacTest.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jvm.compiler.javac + +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8Test + +abstract class AbstractLoadJava8UsingJavacTest : AbstractLoadJava8Test() { + override fun registerJavacIfNeeded(environment: KotlinCoreEnvironment) { + environment.registerJavac() + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + } + + override fun useJavacWrapper() = true +} \ No newline at end of file diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java new file mode 100644 index 00000000000..a346b9ddffa --- /dev/null +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java @@ -0,0 +1,92 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jvm.compiler.javac; + +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") +@RunWith(JUnit3RunnerWithInners.class) +public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJavacTest { + @TestMetadata("compiler/testData/loadJava8/compiledJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompiledJava extends AbstractLoadJava8UsingJavacTest { + public void testAllFilesPresentInCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("InnerClassTypeAnnotation.java") + public void testInnerClassTypeAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/InnerClassTypeAnnotation.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MapRemove.java") + public void testMapRemove() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/MapRemove.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeAnnotations.java") + public void testTypeAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParameterAnnotations.java") + public void testTypeParameterAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava8/sourceJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SourceJava extends AbstractLoadJava8UsingJavacTest { + public void testAllFilesPresentInSourceJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("MapRemove.java") + public void testMapRemove() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/MapRemove.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("TypeAnnotations.java") + public void testTypeAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("TypeParameterAnnotations.java") + public void testTypeParameterAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java"); + doTestSourceJava(fileName); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt b/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt new file mode 100644 index 00000000000..6a30c711d9c --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt @@ -0,0 +1,48 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac + +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTestWithStdLib +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.utils.PathUtil +import java.io.File + +abstract class AbstractDiagnosticsTestWithStdLibUsingJavac : AbstractDiagnosticsTestWithStdLib() { + + override fun analyzeAndCheck(testDataFile: File, files: List) { + if (InTextDirectivesUtils.isDirectiveDefined(testDataFile.readText(), "// JAVAC_SKIP")) { + println("${testDataFile.name} test is skipped") + return + } + val groupedByModule = files.groupBy(TestFile::module) + val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } + val mockJdk = listOf(File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar")) + + environment.registerJavac(kotlinFiles = allKtFiles, bootClasspath = mockJdk) + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + super.analyzeAndCheck(testDataFile, files) + } + + private fun getHomeDirectory(): String { + val resourceRoot = PathUtil.getResourcePathForClass(KotlinTestUtils::class.java) + return FileUtil.toSystemIndependentName(resourceRoot.parentFile.parentFile.parent) + } + +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacForeignAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacForeignAnnotationsTest.kt new file mode 100644 index 00000000000..701c8f59275 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacForeignAnnotationsTest.kt @@ -0,0 +1,34 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac + +import org.jetbrains.kotlin.checkers.AbstractForeignAnnotationsTest +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import java.io.File + +abstract class AbstractJavacForeignAnnotationsTest : AbstractForeignAnnotationsTest() { + + override fun analyzeAndCheck(testDataFile: File, files: List) { + val groupedByModule = files.groupBy(TestFile::module) + val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } + environment.registerJavac(kotlinFiles = allKtFiles) + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + + super.analyzeAndCheck(testDataFile, files) + } + +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacForeignJava8AnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacForeignJava8AnnotationsTest.kt new file mode 100644 index 00000000000..a4ec046a3b4 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacForeignJava8AnnotationsTest.kt @@ -0,0 +1,34 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac + +import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsTest +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import java.io.File + +abstract class AbstractJavacForeignJava8AnnotationsTest : AbstractForeignJava8AnnotationsTest() { + + override fun analyzeAndCheck(testDataFile: File, files: List) { + val groupedByModule = files.groupBy(TestFile::module) + val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } + environment.registerJavac(kotlinFiles = allKtFiles) + environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + + super.analyzeAndCheck(testDataFile, files) + } + +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java new file mode 100644 index 00000000000..53ece11e23a --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsTestWithStdLibUsingJavacGenerated.java @@ -0,0 +1,1853 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac; + +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/diagnostics/testsWithStdLib") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class DiagnosticsTestWithStdLibUsingJavacGenerated extends AbstractDiagnosticsTestWithStdLibUsingJavac { + @TestMetadata("addAllProjection.kt") + public void testAddAllProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInTestsWithStdLib() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ArrayOfNothing.kt") + public void testArrayOfNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt"); + doTest(fileName); + } + + @TestMetadata("CallCompanionProtectedNonStatic.kt") + public void testCallCompanionProtectedNonStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/CallCompanionProtectedNonStatic.kt"); + doTest(fileName); + } + + @TestMetadata("CallToMainRedeclaredInMultiFile.kt") + public void testCallToMainRedeclaredInMultiFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/CallToMainRedeclaredInMultiFile.kt"); + doTest(fileName); + } + + @TestMetadata("commonCollections.kt") + public void testCommonCollections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt"); + doTest(fileName); + } + + @TestMetadata("elvisOnJavaList.kt") + public void testElvisOnJavaList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt"); + doTest(fileName); + } + + @TestMetadata("elvisOnUnitInLet.kt") + public void testElvisOnUnitInLet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/elvisOnUnitInLet.kt"); + doTest(fileName); + } + + @TestMetadata("ifElseJavaList.kt") + public void testIfElseJavaList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/ifElseJavaList.kt"); + doTest(fileName); + } + + @TestMetadata("implicitCastToAny.kt") + public void testImplicitCastToAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt"); + doTest(fileName); + } + + @TestMetadata("InaccessibleInternalClass.kt") + public void testInaccessibleInternalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/InaccessibleInternalClass.kt"); + doTest(fileName); + } + + @TestMetadata("instar.kt") + public void testInstar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/instar.kt"); + doTest(fileName); + } + + @TestMetadata("javaClassOnCompanion.kt") + public void testJavaClassOnCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/javaClassOnCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("javaForKClass.kt") + public void testJavaForKClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/javaForKClass.kt"); + doTest(fileName); + } + + @TestMetadata("kt9078.kt") + public void testKt9078() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/kt9078.kt"); + doTest(fileName); + } + + @TestMetadata("kt9985.kt") + public void testKt9985() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/kt9985.kt"); + doTest(fileName); + } + + @TestMetadata("outstar.kt") + public void testOutstar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/outstar.kt"); + doTest(fileName); + } + + @TestMetadata("overrideWithFunctionalType.kt") + public void testOverrideWithFunctionalType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/overrideWithFunctionalType.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyDelegateWithPrivateSet.kt") + public void testPropertyDelegateWithPrivateSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/PropertyDelegateWithPrivateSet.kt"); + doTest(fileName); + } + + @TestMetadata("pureReifiable.kt") + public void testPureReifiable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/pureReifiable.kt"); + doTest(fileName); + } + + @TestMetadata("pureReifiableArrayOperations.kt") + public void testPureReifiableArrayOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/pureReifiableArrayOperations.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationMainInMultiFileClass.kt") + public void testRedeclarationMainInMultiFileClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/RedeclarationMainInMultiFileClass.kt"); + doTest(fileName); + } + + @TestMetadata("RenameOnImportHidesDefaultImport.kt") + public void testRenameOnImportHidesDefaultImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/RenameOnImportHidesDefaultImport.kt"); + doTest(fileName); + } + + @TestMetadata("shadowingInDestructuring.kt") + public void testShadowingInDestructuring() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/shadowingInDestructuring.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassObjectAnnotatedWithItsKClass.kt") + public void testClassObjectAnnotatedWithItsKClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.kt"); + doTest(fileName); + } + + @TestMetadata("defaultValueMustBeConstant.kt") + public void testDefaultValueMustBeConstant() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.kt"); + doTest(fileName); + } + + @TestMetadata("JvmSyntheticOnDelegate.kt") + public void testJvmSyntheticOnDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/JvmSyntheticOnDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedCallValue.kt") + public void testQualifiedCallValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.kt"); + doTest(fileName); + } + + @TestMetadata("strictfpOnClass.kt") + public void testStrictfpOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/strictfpOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("Synchronized.kt") + public void testSynchronized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/Synchronized.kt"); + doTest(fileName); + } + + @TestMetadata("targetuse.kt") + public void testTargetuse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/targetuse.kt"); + doTest(fileName); + } + + @TestMetadata("TransientOnDelegate.kt") + public void testTransientOnDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/TransientOnDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("Volatile.kt") + public void testVolatile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotationApplicability extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInAnnotationApplicability() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationsOnUseSiteTargets.kt") + public void testAnnotationsOnUseSiteTargets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt"); + doTest(fileName); + } + + @TestMetadata("illegalPlatformName.kt") + public void testIllegalPlatformName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/illegalPlatformName.kt"); + doTest(fileName); + } + + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmName.kt"); + doTest(fileName); + } + + @TestMetadata("multifileClassPart.kt") + public void testMultifileClassPart() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.kt"); + doTest(fileName); + } + + @TestMetadata("multifileClassPartWithJavaAnnotation.kt") + public void testMultifileClassPartWithJavaAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("suppressOnFunctionReference.kt") + public void testSuppressOnFunctionReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotationParameterMustBeConstant extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("array.kt") + public void testArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.kt"); + doTest(fileName); + } + + @TestMetadata("useOfNonConstVal.kt") + public void testUseOfNonConstVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt"); + doTest(fileName); + } + + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotationParameters extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInAnnotationParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt10136.kt") + public void testKt10136() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/kt10136.kt"); + doTest(fileName); + } + + @TestMetadata("nonConstValAsArgument.kt") + public void testNonConstValAsArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/nonConstValAsArgument.kt"); + doTest(fileName); + } + + @TestMetadata("orderWithValue.kt") + public void testOrderWithValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.kt"); + doTest(fileName); + } + + @TestMetadata("orderWithoutValue.kt") + public void testOrderWithoutValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.kt"); + doTest(fileName); + } + + @TestMetadata("valueArray.kt") + public void testValueArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt"); + doTest(fileName); + } + + @TestMetadata("valueArrayAndOtherDefault.kt") + public void testValueArrayAndOtherDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.kt"); + doTest(fileName); + } + + @TestMetadata("valueArrayOnly.kt") + public void testValueArrayOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.kt"); + doTest(fileName); + } + + @TestMetadata("valueArrayWithDefault.kt") + public void testValueArrayWithDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotationWithVarargParameter extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInAnnotationWithVarargParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("javaAnnotationWithVarargArgument.kt") + public void testJavaAnnotationWithVarargArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinAnnotationWithVarargArgument.kt") + public void testKotlinAnnotationWithVarargArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaAnnotationsWithKClassParameter extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInJavaAnnotationsWithKClassParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationAsArgument.kt") + public void testAnnotationAsArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.kt"); + doTest(fileName); + } + + @TestMetadata("arg.kt") + public void testArg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.kt"); + doTest(fileName); + } + + @TestMetadata("argAndOtherDefault.kt") + public void testArgAndOtherDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.kt"); + doTest(fileName); + } + + @TestMetadata("argArray.kt") + public void testArgArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.kt"); + doTest(fileName); + } + + @TestMetadata("argWithDefault.kt") + public void testArgWithDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.kt"); + doTest(fileName); + } + + @TestMetadata("argWithDefaultAndOther.kt") + public void testArgWithDefaultAndOther() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.kt"); + doTest(fileName); + } + + @TestMetadata("twoArgs.kt") + public void testTwoArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.kt"); + doTest(fileName); + } + + @TestMetadata("value.kt") + public void testValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.kt"); + doTest(fileName); + } + + @TestMetadata("valueAndOtherDefault.kt") + public void testValueAndOtherDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.kt"); + doTest(fileName); + } + + @TestMetadata("valueArray.kt") + public void testValueArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.kt"); + doTest(fileName); + } + + @TestMetadata("valueWithDefault.kt") + public void testValueWithDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.kt"); + doTest(fileName); + } + + @TestMetadata("valueWithDefaultAndOther.kt") + public void testValueWithDefaultAndOther() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmField extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInJvmField() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("clashWithCompanionObjectField.kt") + public void testClashWithCompanionObjectField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.kt"); + doTest(fileName); + } + + @TestMetadata("inMultiFileFacade.kt") + public void testInMultiFileFacade() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.kt"); + doTest(fileName); + } + + @TestMetadata("inSingleFileFacade.kt") + public void testInSingleFileFacade() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.kt"); + doTest(fileName); + } + + @TestMetadata("jvmFieldApplicability.kt") + public void testJvmFieldApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmOverloads extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInJvmOverloads() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("JvmOverloadWithNoDefaults.kt") + public void testJvmOverloadWithNoDefaults() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt"); + doTest(fileName); + } + + @TestMetadata("jvmOverloadsOnAbstractMethods.kt") + public void testJvmOverloadsOnAbstractMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt"); + doTest(fileName); + } + + @TestMetadata("jvmOverloadsOnPrivate.kt") + public void testJvmOverloadsOnPrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmStatic extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInJvmStatic() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("constOrJvmFieldProperty.kt") + public void testConstOrJvmFieldProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.kt"); + doTest(fileName); + } + + @TestMetadata("constructorProperty.kt") + public void testConstructorProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty.kt"); + doTest(fileName); + } + + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructors.kt"); + doTest(fileName); + } + + @TestMetadata("finalAndAbstract.kt") + public void testFinalAndAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/finalAndAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions.kt"); + doTest(fileName); + } + + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/localFun.kt"); + doTest(fileName); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KClass extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInKClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kClassArrayInAnnotationsInVariance.kt") + public void testKClassArrayInAnnotationsInVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt"); + doTest(fileName); + } + + @TestMetadata("kClassArrayInAnnotationsOutVariance.kt") + public void testKClassArrayInAnnotationsOutVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt"); + doTest(fileName); + } + + @TestMetadata("kClassInAnnotation.kt") + public void testKClassInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("kClassInAnnotationsInVariance.kt") + public void testKClassInAnnotationsInVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.kt"); + doTest(fileName); + } + + @TestMetadata("kClassInAnnotationsOutVariance.kt") + public void testKClassInAnnotationsOutVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.kt"); + doTest(fileName); + } + + @TestMetadata("kClassInvariantTP.kt") + public void testKClassInvariantTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.kt"); + doTest(fileName); + } + + @TestMetadata("kClassOutArrayInAnnotationsOutVariance.kt") + public void testKClassOutArrayInAnnotationsOutVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProhibitPositionedArgument extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInProhibitPositionedArgument() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kotlinAnnotation.kt") + public void testKotlinAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("tooManyArgs.kt") + public void testTooManyArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatch.kt") + public void testTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("withValue.kt") + public void testWithValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.kt"); + doTest(fileName); + } + + @TestMetadata("withoutValue.kt") + public void testWithoutValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/builtins") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Builtins extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInBuiltins() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arraysAreCloneable.kt") + public void testArraysAreCloneable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/builtins/arraysAreCloneable.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/cast") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Cast extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInCast() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AsInsideIn.kt") + public void testAsInsideIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt"); + doTest(fileName); + } + + @TestMetadata("IsArray.kt") + public void testIsArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/cast/IsArray.kt"); + doTest(fileName); + } + + @TestMetadata("IsReified.kt") + public void testIsReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/cast/IsReified.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Coroutines extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInCoroutines() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callableReferences.kt") + public void testCallableReferences() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReferences.kt"); + doTest(fileName); + } + + @TestMetadata("coroutinesDisabled.kt") + public void testCoroutinesDisabled() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/coroutinesDisabled.kt"); + doTest(fileName); + } + + @TestMetadata("coroutinesEnabledWithWarning.kt") + public void testCoroutinesEnabledWithWarning() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/coroutinesEnabledWithWarning.kt"); + doTest(fileName); + } + + @TestMetadata("illegalSuspendCalls.kt") + public void testIllegalSuspendCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantSuspendDeclarations.kt") + public void testIrrelevantSuspendDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/irrelevantSuspendDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaExpectedType.kt") + public void testLambdaExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("mixingSuspendability.kt") + public void testMixingSuspendability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/mixingSuspendability.kt"); + doTest(fileName); + } + + @TestMetadata("noDefaultCoroutineImports.kt") + public void testNoDefaultCoroutineImports() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/noDefaultCoroutineImports.kt"); + doTest(fileName); + } + + @TestMetadata("nonLocalSuspension.kt") + public void testNonLocalSuspension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonLocalSuspension.kt"); + doTest(fileName); + } + + @TestMetadata("operators.kt") + public void testOperators() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/operators.kt"); + doTest(fileName); + } + + @TestMetadata("suspendApplicability.kt") + public void testSuspendApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendApplicability.kt"); + doTest(fileName); + } + + @TestMetadata("suspendConflictsWithNoSuspend.kt") + public void testSuspendConflictsWithNoSuspend() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendConflictsWithNoSuspend.kt"); + doTest(fileName); + } + + @TestMetadata("suspendCoroutineOrReturn.kt") + public void testSuspendCoroutineOrReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt"); + doTest(fileName); + } + + @TestMetadata("suspendCoroutineUnavailableWithNewAPI.kt") + public void testSuspendCoroutineUnavailableWithNewAPI() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt"); + doTest(fileName); + } + + @TestMetadata("suspendCoroutineUnavailableWithOldAPI.kt") + public void testSuspendCoroutineUnavailableWithOldAPI() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt"); + doTest(fileName); + } + + @TestMetadata("suspendDestructuring.kt") + public void testSuspendDestructuring() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendDestructuring.kt"); + doTest(fileName); + } + + @TestMetadata("suspendExternalFunctions.kt") + public void testSuspendExternalFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("suspendFunctions.kt") + public void testSuspendFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("suspendOverridability.kt") + public void testSuspendOverridability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendOverridability.kt"); + doTest(fileName); + } + + @TestMetadata("suspesionInDefaultValue.kt") + public void testSuspesionInDefaultValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspesionInDefaultValue.kt"); + doTest(fileName); + } + + @TestMetadata("tryCatchLambda.kt") + public void testTryCatchLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt"); + doTest(fileName); + } + + @TestMetadata("unsupported.kt") + public void testUnsupported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/unsupported.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inference extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInInference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("correctMember.kt") + public void testCorrectMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/correctMember.kt"); + doTest(fileName); + } + + @TestMetadata("extensionPriority.kt") + public void testExtensionPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionPriority.kt"); + doTest(fileName); + } + + @TestMetadata("extensionSuspend.kt") + public void testExtensionSuspend() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionSuspend.kt"); + doTest(fileName); + } + + @TestMetadata("incorrectCalls.kt") + public void testIncorrectCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt"); + doTest(fileName); + } + + @TestMetadata("kt15516.kt") + public void testKt15516() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt15516.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveGenerators.kt") + public void testRecursiveGenerators() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveGenerators2.kt") + public void testRecursiveGenerators2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeInference.kt") + public void testReturnTypeInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeInference2.kt") + public void testReturnTypeInference2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference2.kt"); + doTest(fileName); + } + + @TestMetadata("simpleGenerator.kt") + public void testSimpleGenerator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/simpleGenerator.kt"); + doTest(fileName); + } + + @TestMetadata("typeFromReceiver.kt") + public void testTypeFromReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/typeFromReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("withParameter.kt") + public void testWithParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withParameter.kt"); + doTest(fileName); + } + + @TestMetadata("withUninferredParameter.kt") + public void testWithUninferredParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class RestrictSuspension extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInRestrictSuspension() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("allMembersAllowed.kt") + public void testAllMembersAllowed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/allMembersAllowed.kt"); + doTest(fileName); + } + + @TestMetadata("extensions.kt") + public void testExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/extensions.kt"); + doTest(fileName); + } + + @TestMetadata("notRelatedFun.kt") + public void testNotRelatedFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/notRelatedFun.kt"); + doTest(fileName); + } + + @TestMetadata("sameInstance.kt") + public void testSameInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/sameInstance.kt"); + doTest(fileName); + } + + @TestMetadata("simpleForbidden.kt") + public void testSimpleForbidden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/simpleForbidden.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SuspendFunctionType extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInSuspendFunctionType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("functionVsSuspendFunction.kt") + public void testFunctionVsSuspendFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.kt"); + doTest(fileName); + } + + @TestMetadata("inference1.kt") + public void testInference1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference1.kt"); + doTest(fileName); + } + + @TestMetadata("inference2.kt") + public void testInference2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference2.kt"); + doTest(fileName); + } + + @TestMetadata("inference3.kt") + public void testInference3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference3.kt"); + doTest(fileName); + } + + @TestMetadata("inference4.kt") + public void testInference4() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference4.kt"); + doTest(fileName); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inline.kt"); + doTest(fileName); + } + + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/invoke.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaInOverriddenValInitializer.kt") + public void testLambdaInOverriddenValInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/lambdaInOverriddenValInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaInValInitializer.kt") + public void testLambdaInValInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/lambdaInValInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("modifierApplicability.kt") + public void testModifierApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/modifierApplicability.kt"); + doTest(fileName); + } + + @TestMetadata("noInvokeForSuspendFunction.kt") + public void testNoInvokeForSuspendFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/noInvokeForSuspendFunction.kt"); + doTest(fileName); + } + + @TestMetadata("noValueParameters.kt") + public void testNoValueParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/noValueParameters.kt"); + doTest(fileName); + } + + @TestMetadata("nullableSuspendFunction.kt") + public void testNullableSuspendFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/nullableSuspendFunction.kt"); + doTest(fileName); + } + + @TestMetadata("suspendFunctionNIsUnresolved.kt") + public void testSuspendFunctionNIsUnresolved() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionNIsUnresolved.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TailCalls extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInTailCalls() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("forbidden.kt") + public void testForbidden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/forbidden.kt"); + doTest(fileName); + } + + @TestMetadata("localFunctions.kt") + public void testLocalFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/localFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("nothingTypedSuspendFunction.kt") + public void testNothingTypedSuspendFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction.kt"); + doTest(fileName); + } + + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/recursive.kt"); + doTest(fileName); + } + + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/tryCatch.kt"); + doTest(fileName); + } + + @TestMetadata("valid.kt") + public void testValid() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/valid.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DuplicateJvmSignature extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("jvmNames.kt") + public void testJvmNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmNames.kt"); + doTest(fileName); + } + + @TestMetadata("jvmNamesDuplicate.kt") + public void testJvmNamesDuplicate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmNamesDuplicate.kt"); + doTest(fileName); + } + + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmOverloads.kt"); + doTest(fileName); + } + + @TestMetadata("jvmStaticInClassObject.kt") + public void testJvmStaticInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmStaticInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("jvmStaticInObject.kt") + public void testJvmStaticInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmStaticInObject.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Statics extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInStatics() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("jjk.kt") + public void testJjk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt"); + doTest(fileName); + } + + @TestMetadata("jk.kt") + public void testJk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt"); + doTest(fileName); + } + + @TestMetadata("jkjk.kt") + public void testJkjk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") + public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/functionLiterals") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionLiterals extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInFunctionLiterals() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("pseudocodeMemoryOverhead.kt") + public void testPseudocodeMemoryOverhead() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inference extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInInference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayConstructor.kt") + public void testArrayConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/arrayConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("kt11266.kt") + public void testKt11266() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt"); + doTest(fileName); + } + + @TestMetadata("kt1558.kt") + public void testKt1558() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.kt"); + doTest(fileName); + } + + @TestMetadata("kt3458.kt") + public void testKt3458() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt"); + doTest(fileName); + } + + @TestMetadata("kt4975.kt") + public void testKt4975() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotationsForResolve extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInAnnotationsForResolve() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("exactAnnotation.kt") + public void testExactAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("internalAnnotationsOnTypes.kt") + public void testInternalAnnotationsOnTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/internalAnnotationsOnTypes.kt"); + doTest(fileName); + } + + @TestMetadata("noInferAndLowPriority.kt") + public void testNoInferAndLowPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt"); + doTest(fileName); + } + + @TestMetadata("noInferAnnotation.kt") + public void testNoInferAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("onlyInputTypesAndLowPriority.kt") + public void testOnlyInputTypesAndLowPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt"); + doTest(fileName); + } + + @TestMetadata("onlyInputTypesAnnotationWithPlatformTypes.kt") + public void testOnlyInputTypesAnnotationWithPlatformTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAnnotationWithPlatformTypes.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithOnlyInputTypesAnnotation.kt") + public void testResolveWithOnlyInputTypesAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inline extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("inlineOnlySuppressesNothingToInline.kt") + public void testInlineOnlySuppressesNothingToInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/inline/inlineOnlySuppressesNothingToInline.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/kt7585") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt7585 extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInKt7585() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/native") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Native extends AbstractDiagnosticsTestWithStdLibUsingJavac { + @TestMetadata("abstract.kt") + public void testAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/abstract.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInNative() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/native"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("body.kt") + public void testBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/body.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/inline.kt"); + doTest(fileName); + } + + @TestMetadata("noBody.kt") + public void testNoBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/noBody.kt"); + doTest(fileName); + } + + @TestMetadata("nonFunction.kt") + public void testNonFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/nonFunction.kt"); + doTest(fileName); + } + + @TestMetadata("override.kt") + public void testOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/override.kt"); + doTest(fileName); + } + + @TestMetadata("reified.kt") + public void testReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/reified.kt"); + doTest(fileName); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/native/trait.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PurelyImplementedCollection extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInPurelyImplementedCollection() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt"); + doTest(fileName); + } + + @TestMetadata("arrayListNullable.kt") + public void testArrayListNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt"); + doTest(fileName); + } + + @TestMetadata("customClassMutableCollection.kt") + public void testCustomClassMutableCollection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt"); + doTest(fileName); + } + + @TestMetadata("customClassMutableList.kt") + public void testCustomClassMutableList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt"); + doTest(fileName); + } + + @TestMetadata("invalidFqName.kt") + public void testInvalidFqName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt"); + doTest(fileName); + } + + @TestMetadata("maps.kt") + public void testMaps() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt"); + doTest(fileName); + } + + @TestMetadata("mapsWithNullableKey.kt") + public void testMapsWithNullableKey() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt"); + doTest(fileName); + } + + @TestMetadata("mapsWithNullableValues.kt") + public void testMapsWithNullableValues() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt"); + doTest(fileName); + } + + @TestMetadata("sets.kt") + public void testSets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt"); + doTest(fileName); + } + + @TestMetadata("wrongTypeParametersCount.kt") + public void testWrongTypeParametersCount() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/regression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Regression extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInRegression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ea63992.kt") + public void testEa63992() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/ea63992.kt"); + doTest(fileName); + } + + @TestMetadata("ea65206.kt") + public void testEa65206() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/ea65206.kt"); + doTest(fileName); + } + + @TestMetadata("ea66827_dataClassWrongToString.kt") + public void testEa66827_dataClassWrongToString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.kt"); + doTest(fileName); + } + + @TestMetadata("ea70485_functionTypeInheritor.kt") + public void testEa70485_functionTypeInheritor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.kt"); + doTest(fileName); + } + + @TestMetadata("ea70880_illegalJvmName.kt") + public void testEa70880_illegalJvmName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.kt"); + doTest(fileName); + } + + @TestMetadata("kt10001.kt") + public void testKt10001() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/kt10001.kt"); + doTest(fileName); + } + + @TestMetadata("kt2082.kt") + public void testKt2082() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.kt"); + doTest(fileName); + } + + @TestMetadata("kt9345.kt") + public void testKt9345() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/kt9345.kt"); + doTest(fileName); + } + + @TestMetadata("kt9820_javaFunctionTypeInheritor.kt") + public void testKt9820_javaFunctionTypeInheritor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/reified") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Reified extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInReified() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayConstruction.kt") + public void testArrayConstruction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.kt"); + doTest(fileName); + } + + @TestMetadata("arrayOfNullsReified.kt") + public void testArrayOfNullsReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.kt"); + doTest(fileName); + } + + @TestMetadata("nonCallableReiefied.kt") + public void testNonCallableReiefied() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/reified/nonCallableReiefied.kt"); + doTest(fileName); + } + + @TestMetadata("reifiedNothingSubstitution.kt") + public void testReifiedNothingSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Resolve extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInResolve() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("hidesMembers.kt") + public void testHidesMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt"); + doTest(fileName); + } + + @TestMetadata("hidesMembers2.kt") + public void testHidesMembers2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt"); + doTest(fileName); + } + + @TestMetadata("javaPackageMembers.kt") + public void testJavaPackageMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/javaPackageMembers.kt"); + doTest(fileName); + } + + @TestMetadata("javaStaticMembers.kt") + public void testJavaStaticMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt"); + doTest(fileName); + } + + @TestMetadata("kt10103.kt") + public void testKt10103() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/kt10103.kt"); + doTest(fileName); + } + + @TestMetadata("kt10732a.kt") + public void testKt10732a() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/kt10732a.kt"); + doTest(fileName); + } + + @TestMetadata("kt4711.kt") + public void testKt4711() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt"); + doTest(fileName); + } + + @TestMetadata("samAgainstFunctionalType.kt") + public void testSamAgainstFunctionalType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt"); + doTest(fileName); + } + + @TestMetadata("samConstructorVsFun.kt") + public void testSamConstructorVsFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.kt"); + doTest(fileName); + } + + @TestMetadata("samOverloadsWithGenerics.kt") + public void testSamOverloadsWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("samOverloadsWithGenericsWithoutRefinedSams.kt") + public void testSamOverloadsWithGenericsWithoutRefinedSams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.kt"); + doTest(fileName); + } + + @TestMetadata("samOverloadsWithKtFunction.kt") + public void testSamOverloadsWithKtFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt"); + doTest(fileName); + } + + @TestMetadata("samOverloadsWithKtFunctionWithoutRefinedSams.kt") + public void testSamOverloadsWithKtFunctionWithoutRefinedSams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Smartcasts extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInSmartcasts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("forEachSafe.kt") + public void testForEachSafe() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt"); + doTest(fileName); + } + + @TestMetadata("forEachUnsafe.kt") + public void testForEachUnsafe() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt"); + doTest(fileName); + } + + @TestMetadata("kt10463.kt") + public void testKt10463() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/kt10463.kt"); + doTest(fileName); + } + + @TestMetadata("lazyDeclaresAndModifies.kt") + public void testLazyDeclaresAndModifies() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/lazyDeclaresAndModifies.kt"); + doTest(fileName); + } + + @TestMetadata("letAlwaysChangesToNotNull.kt") + public void testLetAlwaysChangesToNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letAlwaysChangesToNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("letChangesToNotNull.kt") + public void testLetChangesToNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("letChangesToNull.kt") + public void testLetChangesToNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNull.kt"); + doTest(fileName); + } + + @TestMetadata("letChangesToNullComplex.kt") + public void testLetChangesToNullComplex() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNullComplex.kt"); + doTest(fileName); + } + + @TestMetadata("letMergeNotNull.kt") + public void testLetMergeNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letMergeNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("letStable.kt") + public void testLetStable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letStable.kt"); + doTest(fileName); + } + + @TestMetadata("letUsesOwnReceiver.kt") + public void testLetUsesOwnReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letUsesOwnReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("listOfGeneric.kt") + public void testListOfGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/listOfGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("withChangesToNull.kt") + public void testWithChangesToNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts/withChangesToNull.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SourceCompatibility extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInSourceCompatibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("noDefaultImportOfKotlinComparisons.kt") + public void testNoDefaultImportOfKotlinComparisons() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility/noDefaultImportOfKotlinComparisons.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Typealias extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInTypealias() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("exceptionTypeAliases.kt") + public void testExceptionTypeAliases() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliases.kt"); + doTest(fileName); + } + + @TestMetadata("exceptionTypeAliasesInvisibleWithApiVersion1_0.kt") + public void testExceptionTypeAliasesInvisibleWithApiVersion1_0() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliasesInvisibleWithApiVersion1_0.kt"); + doTest(fileName); + } + + @TestMetadata("exceptionTypeAliasesInvisibleWithoutFeature.kt") + public void testExceptionTypeAliasesInvisibleWithoutFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliasesInvisibleWithoutFeature.kt"); + doTest(fileName); + } + + @TestMetadata("hashMapTypeAlias.kt") + public void testHashMapTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias/hashMapTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasSamAdapterConstructors.kt") + public void testTypeAliasSamAdapterConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasSamAdapterConstructors2.kt") + public void testTypeAliasSamAdapterConstructors2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors2.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/varargs") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Varargs extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInVarargs() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt3213.kt") + public void testKt3213() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/varargs/kt3213.kt"); + doTest(fileName); + } + + @TestMetadata("kt4172j.kt") + public void testKt4172j() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/varargs/kt4172j.kt"); + doTest(fileName); + } + + @TestMetadata("kt5534.kt") + public void testKt5534() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/varargs/kt5534.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/when") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class When extends AbstractDiagnosticsTestWithStdLibUsingJavac { + public void testAllFilesPresentInWhen() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt10192.kt") + public void testKt10192() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/when/kt10192.kt"); + doTest(fileName); + } + + @TestMetadata("kt10807.kt") + public void testKt10807() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/when/kt10807.kt"); + doTest(fileName); + } + + @TestMetadata("noTypeArgumentsInConstructor.kt") + public void testNoTypeArgumentsInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt"); + doTest(fileName); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java new file mode 100644 index 00000000000..1b2c2d43142 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -0,0 +1,24146 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac; + +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") +@RunWith(JUnit3RunnerWithInners.class) +public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("compiler/testData/diagnostics/tests") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Tests extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("Abstract.kt") + public void testAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Abstract.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractAccessor.kt") + public void testAbstractAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AbstractAccessor.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractInAbstractClass.kt") + public void testAbstractInAbstractClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractInClass.kt") + public void testAbstractInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AbstractInClass.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractInTrait.kt") + public void testAbstractInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AbstractInTrait.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInTests() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AnonymousInitializerVarAndConstructor.kt") + public void testAnonymousInitializerVarAndConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("AnonymousInitializers.kt") + public void testAnonymousInitializers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AnonymousInitializers.kt"); + doTest(fileName); + } + + @TestMetadata("AssignToArrayElement.kt") + public void testAssignToArrayElement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AssignToArrayElement.kt"); + doTest(fileName); + } + + @TestMetadata("AutoCreatedIt.kt") + public void testAutoCreatedIt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/AutoCreatedIt.kt"); + doTest(fileName); + } + + @TestMetadata("BacktickNames.kt") + public void testBacktickNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/BacktickNames.kt"); + doTest(fileName); + } + + @TestMetadata("Basic.kt") + public void testBasic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Basic.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryCallsOnNullableValues.kt") + public void testBinaryCallsOnNullableValues() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt"); + doTest(fileName); + } + + @TestMetadata("Bounds.kt") + public void testBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Bounds.kt"); + doTest(fileName); + } + + @TestMetadata("BreakContinue.kt") + public void testBreakContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/BreakContinue.kt"); + doTest(fileName); + } + + @TestMetadata("BreakContinueInWhen.kt") + public void testBreakContinueInWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/BreakContinueInWhen.kt"); + doTest(fileName); + } + + @TestMetadata("Builders.kt") + public void testBuilders() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Builders.kt"); + doTest(fileName); + } + + @TestMetadata("Casts.kt") + public void testCasts() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Casts.kt"); + doTest(fileName); + } + + @TestMetadata("CharacterLiterals.kt") + public void testCharacterLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/CharacterLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("checkType.kt") + public void testCheckType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkType.kt"); + doTest(fileName); + } + + @TestMetadata("CompareToWithErrorType.kt") + public void testCompareToWithErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/CompareToWithErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("Constants.kt") + public void testConstants() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Constants.kt"); + doTest(fileName); + } + + @TestMetadata("Constructors.kt") + public void testConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Constructors.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorsOfPrimitives.kt") + public void testConstructorsOfPrimitives() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.kt"); + doTest(fileName); + } + + @TestMetadata("CovariantOverrideType.kt") + public void testCovariantOverrideType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/CovariantOverrideType.kt"); + doTest(fileName); + } + + @TestMetadata("DefaultValueForParameterInFunctionType.kt") + public void testDefaultValueForParameterInFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DefaultValueForParameterInFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("DefaultValuesCheckWithoutBody.kt") + public void testDefaultValuesCheckWithoutBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DefaultValuesCheckWithoutBody.kt"); + doTest(fileName); + } + + @TestMetadata("DefaultValuesTypechecking.kt") + public void testDefaultValuesTypechecking() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt"); + doTest(fileName); + } + + @TestMetadata("DeferredTypes.kt") + public void testDeferredTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DeferredTypes.kt"); + doTest(fileName); + } + + @TestMetadata("DeprecatedGetSetPropertyDelegateConvention.kt") + public void testDeprecatedGetSetPropertyDelegateConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.kt"); + doTest(fileName); + } + + @TestMetadata("DeprecatedUnaryOperatorConventions.kt") + public void testDeprecatedUnaryOperatorConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.kt"); + doTest(fileName); + } + + @TestMetadata("DiamondFunction.kt") + public void testDiamondFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DiamondFunction.kt"); + doTest(fileName); + } + + @TestMetadata("DiamondFunctionGeneric.kt") + public void testDiamondFunctionGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DiamondFunctionGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("DiamondProperty.kt") + public void testDiamondProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/DiamondProperty.kt"); + doTest(fileName); + } + + @TestMetadata("Dollar.kt") + public void testDollar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Dollar.kt"); + doTest(fileName); + } + + @TestMetadata("EnumEntryAsType.kt") + public void testEnumEntryAsType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/EnumEntryAsType.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionCallInvoke.kt") + public void testExtensionCallInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ExtensionCallInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("ExternalAccessors.kt") + public void testExternalAccessors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ExternalAccessors.kt"); + doTest(fileName); + } + + @TestMetadata("ExternalAndAbstract.kt") + public void testExternalAndAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ExternalAndAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("fileDependencyRecursion.kt") + public void testFileDependencyRecursion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/fileDependencyRecursion.kt"); + doTest(fileName); + } + + @TestMetadata("ForRangeConventions.kt") + public void testForRangeConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ForRangeConventions.kt"); + doTest(fileName); + } + + @TestMetadata("FreeFunctionCalledAsExtension.kt") + public void testFreeFunctionCalledAsExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionCalleeExpressions.kt") + public void testFunctionCalleeExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionParameterWithoutType.kt") + public void testFunctionParameterWithoutType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/FunctionParameterWithoutType.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionReturnTypes.kt") + public void testFunctionReturnTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/FunctionReturnTypes.kt"); + doTest(fileName); + } + + @TestMetadata("GenericArgumentConsistency.kt") + public void testGenericArgumentConsistency() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/GenericArgumentConsistency.kt"); + doTest(fileName); + } + + @TestMetadata("GenericFunctionIsLessSpecific.kt") + public void testGenericFunctionIsLessSpecific() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/GenericFunctionIsLessSpecific.kt"); + doTest(fileName); + } + + @TestMetadata("IdentityComparisonWithPrimitives.kt") + public void testIdentityComparisonWithPrimitives() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/IdentityComparisonWithPrimitives.kt"); + doTest(fileName); + } + + @TestMetadata("implicitIntersection.kt") + public void testImplicitIntersection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/implicitIntersection.kt"); + doTest(fileName); + } + + @TestMetadata("implicitNestedIntersection.kt") + public void testImplicitNestedIntersection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/implicitNestedIntersection.kt"); + doTest(fileName); + } + + @TestMetadata("implicitNothing.kt") + public void testImplicitNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/implicitNothing.kt"); + doTest(fileName); + } + + @TestMetadata("IncDec.kt") + public void testIncDec() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/IncDec.kt"); + doTest(fileName); + } + + @TestMetadata("IncorrectCharacterLiterals.kt") + public void testIncorrectCharacterLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("InferNullabilityInThenBlock.kt") + public void testInferNullabilityInThenBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/InferNullabilityInThenBlock.kt"); + doTest(fileName); + } + + @TestMetadata("Infix.kt") + public void testInfix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Infix.kt"); + doTest(fileName); + } + + @TestMetadata("InfixModifierApplicability.kt") + public void testInfixModifierApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/InfixModifierApplicability.kt"); + doTest(fileName); + } + + @TestMetadata("InvokeAndRecursiveResolve.kt") + public void testInvokeAndRecursiveResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/InvokeAndRecursiveResolve.kt"); + doTest(fileName); + } + + @TestMetadata("IsExpressions.kt") + public void testIsExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/IsExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("kt13401.kt") + public void testKt13401() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/kt13401.kt"); + doTest(fileName); + } + + @TestMetadata("kt310.kt") + public void testKt310() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/kt310.kt"); + doTest(fileName); + } + + @TestMetadata("kt435.kt") + public void testKt435() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/kt435.kt"); + doTest(fileName); + } + + @TestMetadata("kt53.kt") + public void testKt53() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/kt53.kt"); + doTest(fileName); + } + + @TestMetadata("LValueAssignment.kt") + public void testLValueAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/LValueAssignment.kt"); + doTest(fileName); + } + + @TestMetadata("LiteralAsResult.kt") + public void testLiteralAsResult() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/LiteralAsResult.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassAndShortSubpackageNames.kt") + public void testLocalClassAndShortSubpackageNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/LocalClassAndShortSubpackageNames.kt"); + doTest(fileName); + } + + @TestMetadata("localInterfaces.kt") + public void testLocalInterfaces() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/localInterfaces.kt"); + doTest(fileName); + } + + @TestMetadata("MultilineStringTemplates.kt") + public void testMultilineStringTemplates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/MultilineStringTemplates.kt"); + doTest(fileName); + } + + @TestMetadata("MultipleBounds.kt") + public void testMultipleBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/MultipleBounds.kt"); + doTest(fileName); + } + + @TestMetadata("NamedFunctionTypeParameterInSupertype.kt") + public void testNamedFunctionTypeParameterInSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("Nullability.kt") + public void testNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Nullability.kt"); + doTest(fileName); + } + + @TestMetadata("NumberPrefixAndSuffix.kt") + public void testNumberPrefixAndSuffix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt"); + doTest(fileName); + } + + @TestMetadata("ObjectWithConstructor.kt") + public void testObjectWithConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ObjectWithConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("OperatorChecks.kt") + public void testOperatorChecks() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/OperatorChecks.kt"); + doTest(fileName); + } + + @TestMetadata("Operators.kt") + public void testOperators() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Operators.kt"); + doTest(fileName); + } + + @TestMetadata("OperatorsWithWrongNames.kt") + public void testOperatorsWithWrongNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/OperatorsWithWrongNames.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideFunctionWithParamDefaultValue.kt") + public void testOverrideFunctionWithParamDefaultValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/OverrideFunctionWithParamDefaultValue.kt"); + doTest(fileName); + } + + @TestMetadata("OverridenFunctionAndSpecifiedTypeParameter.kt") + public void testOverridenFunctionAndSpecifiedTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/OverridenFunctionAndSpecifiedTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("OverridenSetterVisibility.kt") + public void testOverridenSetterVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/OverridenSetterVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("OverridingVarByVal.kt") + public void testOverridingVarByVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/OverridingVarByVal.kt"); + doTest(fileName); + } + + @TestMetadata("PackageInExpressionPosition.kt") + public void testPackageInExpressionPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt"); + doTest(fileName); + } + + @TestMetadata("PackageInTypePosition.kt") + public void testPackageInTypePosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PackageInTypePosition.kt"); + doTest(fileName); + } + + @TestMetadata("PackageQualified.kt") + public void testPackageQualified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PackageQualified.kt"); + doTest(fileName); + } + + @TestMetadata("PrimaryConstructors.kt") + public void testPrimaryConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PrimaryConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateFromOuterPackage.kt") + public void testPrivateFromOuterPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PrivateFromOuterPackage.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateSetterForOverridden.kt") + public void testPrivateSetterForOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PrivateSetterForOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("ProcessingEmptyImport.kt") + public void testProcessingEmptyImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ProcessingEmptyImport.kt"); + doTest(fileName); + } + + @TestMetadata("ProjectionOnFunctionArgumentErrror.kt") + public void testProjectionOnFunctionArgumentErrror() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.kt"); + doTest(fileName); + } + + @TestMetadata("ProjectionsInSupertypes.kt") + public void testProjectionsInSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ProjectionsInSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("Properties.kt") + public void testProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Properties.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyInitializers.kt") + public void testPropertyInitializers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/PropertyInitializers.kt"); + doTest(fileName); + } + + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/publishedApi.kt"); + doTest(fileName); + } + + @TestMetadata("QualifiedExpressions.kt") + public void testQualifiedExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/QualifiedExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("RecursiveResolve.kt") + public void testRecursiveResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/RecursiveResolve.kt"); + doTest(fileName); + } + + @TestMetadata("RecursiveTypeInference.kt") + public void testRecursiveTypeInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/RecursiveTypeInference.kt"); + doTest(fileName); + } + + @TestMetadata("ReserveYield.kt") + public void testReserveYield() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ReserveYield.kt"); + doTest(fileName); + } + + @TestMetadata("ReserveYield2.kt") + public void testReserveYield2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ReserveYield2.kt"); + doTest(fileName); + } + + @TestMetadata("ResolveOfJavaGenerics.kt") + public void testResolveOfJavaGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("ResolveToJava.kt") + public void testResolveToJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ResolveToJava.kt"); + doTest(fileName); + } + + @TestMetadata("Return.kt") + public void testReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Return.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnInFunctionWithoutBody.kt") + public void testReturnInFunctionWithoutBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.kt"); + doTest(fileName); + } + + @TestMetadata("SafeCallInvoke.kt") + public void testSafeCallInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SafeCallInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("SafeCallNonNullReceiver.kt") + public void testSafeCallNonNullReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SafeCallNonNullReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("SafeCallNonNullReceiverReturnNull.kt") + public void testSafeCallNonNullReceiverReturnNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt"); + doTest(fileName); + } + + @TestMetadata("SafeCallOnFakePackage.kt") + public void testSafeCallOnFakePackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SafeCallOnFakePackage.kt"); + doTest(fileName); + } + + @TestMetadata("SafeCallOnSuperReceiver.kt") + public void testSafeCallOnSuperReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SafeCallOnSuperReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("Serializable.kt") + public void testSerializable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Serializable.kt"); + doTest(fileName); + } + + @TestMetadata("SetterVisibility.kt") + public void testSetterVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SetterVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("ShiftFunctionTypes.kt") + public void testShiftFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ShiftFunctionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("SingleUnderscoreUnsupported.kt") + public void testSingleUnderscoreUnsupported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SingleUnderscoreUnsupported.kt"); + doTest(fileName); + } + + @TestMetadata("StarsInFunctionCalls.kt") + public void testStarsInFunctionCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt"); + doTest(fileName); + } + + @TestMetadata("StringPrefixAndSuffix.kt") + public void testStringPrefixAndSuffix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt"); + doTest(fileName); + } + + @TestMetadata("StringTemplates.kt") + public void testStringTemplates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/StringTemplates.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeListChecks.kt") + public void testSupertypeListChecks() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SupertypeListChecks.kt"); + doTest(fileName); + } + + @TestMetadata("SyntaxErrorInTestHighlighting.kt") + public void testSyntaxErrorInTestHighlighting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SyntaxErrorInTestHighlighting.kt"); + doTest(fileName); + } + + @TestMetadata("SyntaxErrorInTestHighlightingEof.kt") + public void testSyntaxErrorInTestHighlightingEof() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/SyntaxErrorInTestHighlightingEof.kt"); + doTest(fileName); + } + + @TestMetadata("tailRecOverridden.kt") + public void testTailRecOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/tailRecOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("tailRecursionComplex.kt") + public void testTailRecursionComplex() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/tailRecursionComplex.kt"); + doTest(fileName); + } + + @TestMetadata("TraitOverrideObjectMethods.kt") + public void testTraitOverrideObjectMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt"); + doTest(fileName); + } + + @TestMetadata("TraitWithConstructor.kt") + public void testTraitWithConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/TraitWithConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("TypeInference.kt") + public void testTypeInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/TypeInference.kt"); + doTest(fileName); + } + + @TestMetadata("TypeMismatchOnOverrideWithSyntaxErrors.kt") + public void testTypeMismatchOnOverrideWithSyntaxErrors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/TypeMismatchOnOverrideWithSyntaxErrors.kt"); + doTest(fileName); + } + + @TestMetadata("Underscore.kt") + public void testUnderscore() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Underscore.kt"); + doTest(fileName); + } + + @TestMetadata("UnderscoreUsageInAnnotation.kt") + public void testUnderscoreUsageInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnderscoreUsageInAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("UnderscoreUsageInCall.kt") + public void testUnderscoreUsageInCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnderscoreUsageInCall.kt"); + doTest(fileName); + } + + @TestMetadata("UnderscoreUsageInCallableRefTypeLHS.kt") + public void testUnderscoreUsageInCallableRefTypeLHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnderscoreUsageInCallableRefTypeLHS.kt"); + doTest(fileName); + } + + @TestMetadata("UnderscoreUsageInType.kt") + public void testUnderscoreUsageInType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnderscoreUsageInType.kt"); + doTest(fileName); + } + + @TestMetadata("UnderscoreUsageInVariableAsFunctionCall.kt") + public void testUnderscoreUsageInVariableAsFunctionCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnderscoreUsageInVariableAsFunctionCall.kt"); + doTest(fileName); + } + + @TestMetadata("UnitByDefaultForFunctionTypes.kt") + public void testUnitByDefaultForFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnitByDefaultForFunctionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("UnitValue.kt") + public void testUnitValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnitValue.kt"); + doTest(fileName); + } + + @TestMetadata("Unresolved.kt") + public void testUnresolved() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Unresolved.kt"); + doTest(fileName); + } + + @TestMetadata("UnusedInDestructuring.kt") + public void testUnusedInDestructuring() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnusedInDestructuring.kt"); + doTest(fileName); + } + + @TestMetadata("UnusedParameters.kt") + public void testUnusedParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnusedParameters.kt"); + doTest(fileName); + } + + @TestMetadata("UnusedParametersVersion10.kt") + public void testUnusedParametersVersion10() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnusedParametersVersion10.kt"); + doTest(fileName); + } + + @TestMetadata("UnusedVariables.kt") + public void testUnusedVariables() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnusedVariables.kt"); + doTest(fileName); + } + + @TestMetadata("ValAndFunOverrideCompatibilityClash.kt") + public void testValAndFunOverrideCompatibilityClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt"); + doTest(fileName); + } + + @TestMetadata("VarargTypes.kt") + public void testVarargTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/VarargTypes.kt"); + doTest(fileName); + } + + @TestMetadata("Varargs.kt") + public void testVarargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Varargs.kt"); + doTest(fileName); + } + + @TestMetadata("Variance.kt") + public void testVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/Variance.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/annotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AmbigiousAnnotationConstructor.kt") + public void testAmbigiousAnnotationConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedConstructor.kt") + public void testAnnotatedConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedConstructorParams.kt") + public void testAnnotatedConstructorParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedLocalObjectFun.kt") + public void testAnnotatedLocalObjectFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedLocalObjectProperty.kt") + public void testAnnotatedLocalObjectProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedLoop.kt") + public void testAnnotatedLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedResultType.kt") + public void testAnnotatedResultType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedTryCatch.kt") + public void testAnnotatedTryCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationAsDefaultParameter.kt") + public void testAnnotationAsDefaultParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationForClassTypeParameter.kt") + public void testAnnotationForClassTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationForFunctionTypeParameter.kt") + public void testAnnotationForFunctionTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationForObject.kt") + public void testAnnotationForObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationForObject.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationIdentifier.kt") + public void testAnnotationIdentifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.kt"); + doTest(fileName); + } + + @TestMetadata("annotationInheritance.kt") + public void testAnnotationInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("annotationModifier.kt") + public void testAnnotationModifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationModifier.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationOnObject.kt") + public void testAnnotationOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("annotationOnParameterInFunctionType.kt") + public void testAnnotationOnParameterInFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationsForClasses.kt") + public void testAnnotationsForClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotationsForPropertyTypeParameter.kt") + public void testAnnotationsForPropertyTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("annotationsOnLambdaAsCallArgument.kt") + public void testAnnotationsOnLambdaAsCallArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt"); + doTest(fileName); + } + + @TestMetadata("annotationsOnNullableTypes.kt") + public void testAnnotationsOnNullableTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.kt"); + doTest(fileName); + } + + @TestMetadata("atAnnotationResolve.kt") + public void testAtAnnotationResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt"); + doTest(fileName); + } + + @TestMetadata("BasicAnnotations.kt") + public void testBasicAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/BasicAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("blockLevelOnTheSameLineWarning.kt") + public void testBlockLevelOnTheSameLineWarning() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/blockLevelOnTheSameLineWarning.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorCall.kt") + public void testConstructorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/ConstructorCall.kt"); + doTest(fileName); + } + + @TestMetadata("DanglingInScript.kt") + public void testDanglingInScript() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/DanglingInScript.kt"); + doTest(fileName); + } + + @TestMetadata("DanglingMixed.kt") + public void testDanglingMixed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/DanglingMixed.kt"); + doTest(fileName); + } + + @TestMetadata("DanglingNoBrackets.kt") + public void testDanglingNoBrackets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("DanglingWithBrackets.kt") + public void testDanglingWithBrackets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/Deprecated.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFunctionType.kt") + public void testExtensionFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/extensionFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("forParameterAnnotationResolve.kt") + public void testForParameterAnnotationResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.kt"); + doTest(fileName); + } + + @TestMetadata("illegalSinceKotlinValue.kt") + public void testIllegalSinceKotlinValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/illegalSinceKotlinValue.kt"); + doTest(fileName); + } + + @TestMetadata("invalidTypesInAnnotationConstructor.kt") + public void testInvalidTypesInAnnotationConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("JavaAnnotationConstructors.kt") + public void testJavaAnnotationConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("kt1860-negative.kt") + public void testKt1860_negative() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt"); + doTest(fileName); + } + + @TestMetadata("kt1860-positive.kt") + public void testKt1860_positive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt"); + doTest(fileName); + } + + @TestMetadata("kt1886annotationBody.kt") + public void testKt1886annotationBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.kt"); + doTest(fileName); + } + + @TestMetadata("missingValOnParameter.kt") + public void testMissingValOnParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/missingValOnParameter.kt"); + doTest(fileName); + } + + @TestMetadata("MultiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/MultiDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("MutuallyRecursivelyAnnotatedGlobalFunction.kt") + public void testMutuallyRecursivelyAnnotatedGlobalFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt"); + doTest(fileName); + } + + @TestMetadata("noNameProperty.kt") + public void testNoNameProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/noNameProperty.kt"); + doTest(fileName); + } + + @TestMetadata("NonAnnotationClass.kt") + public void testNonAnnotationClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/NonAnnotationClass.kt"); + doTest(fileName); + } + + @TestMetadata("onExpression.kt") + public void testOnExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onExpression.kt"); + doTest(fileName); + } + + @TestMetadata("onFunctionParameter.kt") + public void testOnFunctionParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onFunctionParameter.kt"); + doTest(fileName); + } + + @TestMetadata("onInitializer.kt") + public void testOnInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("onLoops.kt") + public void testOnLoops() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onLoops.kt"); + doTest(fileName); + } + + @TestMetadata("onLoopsUnreachable.kt") + public void testOnLoopsUnreachable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.kt"); + doTest(fileName); + } + + @TestMetadata("onMultiDeclaration.kt") + public void testOnMultiDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotated.kt") + public void testRecursivelyAnnotated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedFunctionParameter.kt") + public void testRecursivelyAnnotatedFunctionParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedGlobalFunction.kt") + public void testRecursivelyAnnotatedGlobalFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedGlobalProperty.kt") + public void testRecursivelyAnnotatedGlobalProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedParameter.kt") + public void testRecursivelyAnnotatedParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedParameterType.kt") + public void testRecursivelyAnnotatedParameterType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedParameterWithAt.kt") + public void testRecursivelyAnnotatedParameterWithAt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyAnnotatedProperty.kt") + public void testRecursivelyAnnotatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("RecursivelyIncorrectlyAnnotatedParameter.kt") + public void testRecursivelyIncorrectlyAnnotatedParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.kt"); + doTest(fileName); + } + + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterAsAnnotation.kt") + public void testTypeParameterAsAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/typeParameterAsAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("UnresolvedAnnotationOnObject.kt") + public void testUnresolvedAnnotationOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/UnresolvedAnnotationOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedReferenceRange.kt") + public void testUnresolvedReferenceRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/unresolvedReferenceRange.kt"); + doTest(fileName); + } + + @TestMetadata("WrongAnnotationArgsOnObject.kt") + public void testWrongAnnotationArgsOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotationParameterMustBeConstant extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationConstructorDefaultParameter.kt") + public void testAnnotationConstructorDefaultParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/annotationConstructorDefaultParameter.kt"); + doTest(fileName); + } + + @TestMetadata("booleanLocalVal.kt") + public void testBooleanLocalVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.kt"); + doTest(fileName); + } + + @TestMetadata("compareAndEquals.kt") + public void testCompareAndEquals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.kt"); + doTest(fileName); + } + + @TestMetadata("enumConst.kt") + public void testEnumConst() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.kt"); + doTest(fileName); + } + + @TestMetadata("javaProperties.kt") + public void testJavaProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinProperties.kt") + public void testKotlinProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt"); + doTest(fileName); + } + + @TestMetadata("standaloneInExpression.kt") + public void testStandaloneInExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.kt"); + doTest(fileName); + } + + @TestMetadata("strings.kt") + public void testStrings() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/annotations/options") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Options extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOptions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationAsArg.kt") + public void testAnnotationAsArg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt"); + doTest(fileName); + } + + @TestMetadata("annotationAsArgComplex.kt") + public void testAnnotationAsArgComplex() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt"); + doTest(fileName); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("documented.kt") + public void testDocumented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/documented.kt"); + doTest(fileName); + } + + @TestMetadata("forParam.kt") + public void testForParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/forParam.kt"); + doTest(fileName); + } + + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/functionExpression.kt"); + doTest(fileName); + } + + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/functions.kt"); + doTest(fileName); + } + + @TestMetadata("javaDocumented.kt") + public void testJavaDocumented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt"); + doTest(fileName); + } + + @TestMetadata("javaKotlinTargetRetention.kt") + public void testJavaKotlinTargetRetention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.kt"); + doTest(fileName); + } + + @TestMetadata("javaretention.kt") + public void testJavaretention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/javaretention.kt"); + doTest(fileName); + } + + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("objectLiteral.kt") + public void testObjectLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/objectLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("prefix.kt") + public void testPrefix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/prefix.kt"); + doTest(fileName); + } + + @TestMetadata("repeatable.kt") + public void testRepeatable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/repeatable.kt"); + doTest(fileName); + } + + @TestMetadata("retention.kt") + public void testRetention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/retention.kt"); + doTest(fileName); + } + + @TestMetadata("setterParam.kt") + public void testSetterParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/setterParam.kt"); + doTest(fileName); + } + + @TestMetadata("target.kt") + public void testTarget() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/target.kt"); + doTest(fileName); + } + + @TestMetadata("unrepeatable.kt") + public void testUnrepeatable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/unrepeatable.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/annotations/options/targets") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Targets extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accessors.kt") + public void testAccessors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInTargets() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotation.kt") + public void testAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt"); + doTest(fileName); + } + + @TestMetadata("classifier.kt") + public void testClassifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("empty.kt") + public void testEmpty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt"); + doTest(fileName); + } + + @TestMetadata("expr.kt") + public void testExpr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt"); + doTest(fileName); + } + + @TestMetadata("field.kt") + public void testField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/field.kt"); + doTest(fileName); + } + + @TestMetadata("file.kt") + public void testFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/file.kt"); + doTest(fileName); + } + + @TestMetadata("function.kt") + public void testFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/function.kt"); + doTest(fileName); + } + + @TestMetadata("funtypeargs.kt") + public void testFuntypeargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt"); + doTest(fileName); + } + + @TestMetadata("incorrect.kt") + public void testIncorrect() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt"); + doTest(fileName); + } + + @TestMetadata("init.kt") + public void testInit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/init.kt"); + doTest(fileName); + } + + @TestMetadata("java.kt") + public void testJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/java.kt"); + doTest(fileName); + } + + @TestMetadata("local.kt") + public void testLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/local.kt"); + doTest(fileName); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt"); + doTest(fileName); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/property.kt"); + doTest(fileName); + } + + @TestMetadata("returntype.kt") + public void testReturntype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt"); + doTest(fileName); + } + + @TestMetadata("suppress.kt") + public void testSuppress() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt"); + doTest(fileName); + } + + @TestMetadata("type.kt") + public void testType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/type.kt"); + doTest(fileName); + } + + @TestMetadata("typeParams.kt") + public void testTypeParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.kt"); + doTest(fileName); + } + + @TestMetadata("typeargs.kt") + public void testTypeargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt"); + doTest(fileName); + } + + @TestMetadata("valueparam.kt") + public void testValueparam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithUseSiteTarget extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInWithUseSiteTarget() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DelegateAnnotations.kt") + public void testDelegateAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("FieldAnnotations.kt") + public void testFieldAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("FileAnnotations.kt") + public void testFileAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("GetterAnnotations.kt") + public void testGetterAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("ParamAnnotations.kt") + public void testParamAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyAnnotations.kt") + public void testPropertyAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("ReceiverAnnotations.kt") + public void testReceiverAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("repeatable.kt") + public void testRepeatable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.kt"); + doTest(fileName); + } + + @TestMetadata("SetterAnnotations.kt") + public void testSetterAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("SparamAnnotations.kt") + public void testSparamAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/backingField") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class BackingField extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInBackingField() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("CustomGetSet.kt") + public void testCustomGetSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/CustomGetSet.kt"); + doTest(fileName); + } + + @TestMetadata("CustomGetVal.kt") + public void testCustomGetVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/CustomGetVal.kt"); + doTest(fileName); + } + + @TestMetadata("CustomGetValGlobal.kt") + public void testCustomGetValGlobal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/CustomGetValGlobal.kt"); + doTest(fileName); + } + + @TestMetadata("CustomGetVar.kt") + public void testCustomGetVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/CustomGetVar.kt"); + doTest(fileName); + } + + @TestMetadata("CustomSet.kt") + public void testCustomSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/CustomSet.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionProperty.kt") + public void testExtensionProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/ExtensionProperty.kt"); + doTest(fileName); + } + + @TestMetadata("FieldAsParam.kt") + public void testFieldAsParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldAsParam.kt"); + doTest(fileName); + } + + @TestMetadata("FieldAsProperty.kt") + public void testFieldAsProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldAsProperty.kt"); + doTest(fileName); + } + + @TestMetadata("FieldDerived.kt") + public void testFieldDerived() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldDerived.kt"); + doTest(fileName); + } + + @TestMetadata("FieldInInterface.kt") + public void testFieldInInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldInInterface.kt"); + doTest(fileName); + } + + @TestMetadata("FieldInLocal.kt") + public void testFieldInLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldInLocal.kt"); + doTest(fileName); + } + + @TestMetadata("FieldOnVal.kt") + public void testFieldOnVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldOnVal.kt"); + doTest(fileName); + } + + @TestMetadata("FieldOnVar.kt") + public void testFieldOnVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldOnVar.kt"); + doTest(fileName); + } + + @TestMetadata("FieldReassignment.kt") + public void testFieldReassignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldReassignment.kt"); + doTest(fileName); + } + + @TestMetadata("FieldShadow.kt") + public void testFieldShadow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/FieldShadow.kt"); + doTest(fileName); + } + + @TestMetadata("InitCustomSetter.kt") + public void testInitCustomSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt"); + doTest(fileName); + } + + @TestMetadata("InitOpenSetter.kt") + public void testInitOpenSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt"); + doTest(fileName); + } + + @TestMetadata("kt782packageLevel.kt") + public void testKt782packageLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/kt782packageLevel.kt"); + doTest(fileName); + } + + @TestMetadata("SetterWithExplicitType.kt") + public void testSetterWithExplicitType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/backingField/SetterWithExplicitType.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/callableReference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReference extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCallableReference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("bareType.kt") + public void testBareType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bareType.kt"); + doTest(fileName); + } + + @TestMetadata("classVsPackage.kt") + public void testClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt"); + doTest(fileName); + } + + @TestMetadata("ea81649_errorPropertyLHS.kt") + public void testEa81649_errorPropertyLHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/ea81649_errorPropertyLHS.kt"); + doTest(fileName); + } + + @TestMetadata("emptyLhs.kt") + public void testEmptyLhs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/emptyLhs.kt"); + doTest(fileName); + } + + @TestMetadata("kt15439_completeCall.kt") + public void testKt15439_completeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/kt15439_completeCall.kt"); + doTest(fileName); + } + + @TestMetadata("kt7430_wrongClassOnLHS.kt") + public void testKt7430_wrongClassOnLHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt"); + doTest(fileName); + } + + @TestMetadata("memberExtensionsImportedFromObjectsUnsupported.kt") + public void testMemberExtensionsImportedFromObjectsUnsupported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.kt"); + doTest(fileName); + } + + @TestMetadata("packageInLhs.kt") + public void testPackageInLhs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/packageInLhs.kt"); + doTest(fileName); + } + + @TestMetadata("parsingPriorityOfGenericArgumentsVsLess.kt") + public void testParsingPriorityOfGenericArgumentsVsLess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/parsingPriorityOfGenericArgumentsVsLess.kt"); + doTest(fileName); + } + + @TestMetadata("sam.kt") + public void testSam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/sam.kt"); + doTest(fileName); + } + + @TestMetadata("unused.kt") + public void testUnused() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/unused.kt"); + doTest(fileName); + } + + @TestMetadata("whitespacesInExpression.kt") + public void testWhitespacesInExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/whitespacesInExpression.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Bound extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInBound() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classVsStarImportedCompanion.kt") + public void testClassVsStarImportedCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/classVsStarImportedCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("classVsStarImportedObject.kt") + public void testClassVsStarImportedObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/classVsStarImportedObject.kt"); + doTest(fileName); + } + + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/companionObject.kt"); + doTest(fileName); + } + + @TestMetadata("controlFlow.kt") + public void testControlFlow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/controlFlow.kt"); + doTest(fileName); + } + + @TestMetadata("dataFlow.kt") + public void testDataFlow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/dataFlow.kt"); + doTest(fileName); + } + + @TestMetadata("expectedType.kt") + public void testExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/expectedType.kt"); + doTest(fileName); + } + + @TestMetadata("expressionWithNullableType.kt") + public void testExpressionWithNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("functionCallWithoutArguments.kt") + public void testFunctionCallWithoutArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/functionCallWithoutArguments.kt"); + doTest(fileName); + } + + @TestMetadata("innerNested.kt") + public void testInnerNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/innerNested.kt"); + doTest(fileName); + } + + @TestMetadata("kt12843.kt") + public void testKt12843() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/kt12843.kt"); + doTest(fileName); + } + + @TestMetadata("noThisInSuperCall.kt") + public void testNoThisInSuperCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/noThisInSuperCall.kt"); + doTest(fileName); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/object.kt"); + doTest(fileName); + } + + @TestMetadata("privateToThis.kt") + public void testPrivateToThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.kt"); + doTest(fileName); + } + + @TestMetadata("referenceToStaticMethodOnInstance.kt") + public void testReferenceToStaticMethodOnInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.kt"); + doTest(fileName); + } + + @TestMetadata("reservedExpressionSyntax.kt") + public void testReservedExpressionSyntax() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt"); + doTest(fileName); + } + + @TestMetadata("reservedExpressionSyntax2.kt") + public void testReservedExpressionSyntax2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.kt"); + doTest(fileName); + } + + @TestMetadata("reservedExpressionSyntax3.kt") + public void testReservedExpressionSyntax3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt"); + doTest(fileName); + } + + @TestMetadata("syntheticExtensionOnLHS.kt") + public void testSyntheticExtensionOnLHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/syntheticExtensionOnLHS.kt"); + doTest(fileName); + } + + @TestMetadata("valueOfTypeParameterType.kt") + public void testValueOfTypeParameterType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/bound/valueOfTypeParameterType.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/function") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Function extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("abstractClassConstructors.kt") + public void testAbstractClassConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInFunction() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguityTopLevelVsTopLevel.kt") + public void testAmbiguityTopLevelVsTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/ambiguityTopLevelVsTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("annotationClassConstructor.kt") + public void testAnnotationClassConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("callableRefrenceOnNestedObject.kt") + public void testCallableRefrenceOnNestedObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt"); + doTest(fileName); + } + + @TestMetadata("classMemberVsConstructorLikeFunction.kt") + public void testClassMemberVsConstructorLikeFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.kt"); + doTest(fileName); + } + + @TestMetadata("constructorFromClass.kt") + public void testConstructorFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/constructorFromClass.kt"); + doTest(fileName); + } + + @TestMetadata("constructorFromCompanion.kt") + public void testConstructorFromCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("constructorFromExtension.kt") + public void testConstructorFromExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/constructorFromExtension.kt"); + doTest(fileName); + } + + @TestMetadata("constructorFromExtensionInClass.kt") + public void testConstructorFromExtensionInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/constructorFromExtensionInClass.kt"); + doTest(fileName); + } + + @TestMetadata("constructorFromTopLevel.kt") + public void testConstructorFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/constructorFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("constructorOfNestedClassInObject.kt") + public void testConstructorOfNestedClassInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/constructorOfNestedClassInObject.kt"); + doTest(fileName); + } + + @TestMetadata("differentPackageClass.kt") + public void testDifferentPackageClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt"); + doTest(fileName); + } + + @TestMetadata("differentPackageExtension.kt") + public void testDifferentPackageExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt"); + doTest(fileName); + } + + @TestMetadata("differentPackageTopLevel.kt") + public void testDifferentPackageTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/differentPackageTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("empty.kt") + public void testEmpty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/empty.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFromTopLevel.kt") + public void testExtensionFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("extensionInClassDisallowed.kt") + public void testExtensionInClassDisallowed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.kt"); + doTest(fileName); + } + + @TestMetadata("extensionOnNullable.kt") + public void testExtensionOnNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt"); + doTest(fileName); + } + + @TestMetadata("extensionToSupertype.kt") + public void testExtensionToSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("fakeOverrideType.kt") + public void testFakeOverrideType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.kt"); + doTest(fileName); + } + + @TestMetadata("genericClassFromTopLevel.kt") + public void testGenericClassFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("importedInnerConstructor.kt") + public void testImportedInnerConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/importedInnerConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("innerConstructorFromClass.kt") + public void testInnerConstructorFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt"); + doTest(fileName); + } + + @TestMetadata("innerConstructorFromExtension.kt") + public void testInnerConstructorFromExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt"); + doTest(fileName); + } + + @TestMetadata("innerConstructorFromTopLevel.kt") + public void testInnerConstructorFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("javaStaticMethod.kt") + public void testJavaStaticMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt"); + doTest(fileName); + } + + @TestMetadata("lhsNotAClass.kt") + public void testLhsNotAClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/lhsNotAClass.kt"); + doTest(fileName); + } + + @TestMetadata("localConstructor.kt") + public void testLocalConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("localConstructorFromExtensionInLocalClass.kt") + public void testLocalConstructorFromExtensionInLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromExtensionInLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("localConstructorFromLocalClass.kt") + public void testLocalConstructorFromLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("localConstructorFromLocalExtension.kt") + public void testLocalConstructorFromLocalExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromLocalExtension.kt"); + doTest(fileName); + } + + @TestMetadata("localNamedFun.kt") + public void testLocalNamedFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localNamedFun.kt"); + doTest(fileName); + } + + @TestMetadata("localNamedFunFromExtensionInLocalClass.kt") + public void testLocalNamedFunFromExtensionInLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromExtensionInLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("localNamedFunFromLocalClass.kt") + public void testLocalNamedFunFromLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("localNamedFunFromLocalExtension.kt") + public void testLocalNamedFunFromLocalExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromLocalExtension.kt"); + doTest(fileName); + } + + @TestMetadata("longQualifiedName.kt") + public void testLongQualifiedName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt"); + doTest(fileName); + } + + @TestMetadata("longQualifiedNameGeneric.kt") + public void testLongQualifiedNameGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("memberFromTopLevel.kt") + public void testMemberFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("nestedConstructorFromClass.kt") + public void testNestedConstructorFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.kt"); + doTest(fileName); + } + + @TestMetadata("nestedConstructorFromExtension.kt") + public void testNestedConstructorFromExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.kt"); + doTest(fileName); + } + + @TestMetadata("nestedConstructorFromTopLevel.kt") + public void testNestedConstructorFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("noAmbiguityLocalVsTopLevel.kt") + public void testNoAmbiguityLocalVsTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityLocalVsTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("noAmbiguityMemberVsExtension.kt") + public void testNoAmbiguityMemberVsExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt"); + doTest(fileName); + } + + @TestMetadata("noAmbiguityMemberVsTopLevel.kt") + public void testNoAmbiguityMemberVsTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("privateStaticAndPublicMember.kt") + public void testPrivateStaticAndPublicMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/privateStaticAndPublicMember.kt"); + doTest(fileName); + } + + @TestMetadata("renameOnImport.kt") + public void testRenameOnImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelFromClass.kt") + public void testTopLevelFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromClass.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelFromExtension.kt") + public void testTopLevelFromExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromExtension.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelFromExtensionInClass.kt") + public void testTopLevelFromExtensionInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromExtensionInClass.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelFromTopLevel.kt") + public void testTopLevelFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("unresolved.kt") + public void testUnresolved() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/function/unresolved.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/generic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Generic extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInGeneric() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("argumentAndReturnExpectedType.kt") + public void testArgumentAndReturnExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("argumentExpectedType.kt") + public void testArgumentExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/argumentExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("dependOnArgumentType.kt") + public void testDependOnArgumentType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.kt"); + doTest(fileName); + } + + @TestMetadata("expectedFunctionType.kt") + public void testExpectedFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/expectedFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("explicitTypeArguments.kt") + public void testExplicitTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("genericExtensionFunction.kt") + public void testGenericExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.kt"); + doTest(fileName); + } + + @TestMetadata("genericFunctionsWithNullableTypes.kt") + public void testGenericFunctionsWithNullableTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt"); + doTest(fileName); + } + + @TestMetadata("kt10968.kt") + public void testKt10968() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/kt10968.kt"); + doTest(fileName); + } + + @TestMetadata("kt11075.kt") + public void testKt11075() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/kt11075.kt"); + doTest(fileName); + } + + @TestMetadata("kt12286.kt") + public void testKt12286() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/kt12286.kt"); + doTest(fileName); + } + + @TestMetadata("kt7470.kt") + public void testKt7470() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/kt7470.kt"); + doTest(fileName); + } + + @TestMetadata("nestedCallWithOverload.kt") + public void testNestedCallWithOverload() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt"); + doTest(fileName); + } + + @TestMetadata("noInferenceFeatureForCallableReferences.kt") + public void testNoInferenceFeatureForCallableReferences() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/noInferenceFeatureForCallableReferences.kt"); + doTest(fileName); + } + + @TestMetadata("resolutionGenericCallableWithNullableTypes.kt") + public void testResolutionGenericCallableWithNullableTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.kt"); + doTest(fileName); + } + + @TestMetadata("resolutionWithGenericCallable.kt") + public void testResolutionWithGenericCallable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.kt"); + doTest(fileName); + } + + @TestMetadata("specialCalls.kt") + public void testSpecialCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/generic/specialCalls.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/property") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Property extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("abstractPropertyViaSubclasses.kt") + public void testAbstractPropertyViaSubclasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt"); + doTest(fileName); + } + + @TestMetadata("accessViaSubclass.kt") + public void testAccessViaSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classFromClass.kt") + public void testClassFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFromTopLevel.kt") + public void testExtensionFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("extensionPropertyOnNullable.kt") + public void testExtensionPropertyOnNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/extensionPropertyOnNullable.kt"); + doTest(fileName); + } + + @TestMetadata("genericClass.kt") + public void testGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt"); + doTest(fileName); + } + + @TestMetadata("javaInstanceField.kt") + public void testJavaInstanceField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt"); + doTest(fileName); + } + + @TestMetadata("javaStaticFieldViaImport.kt") + public void testJavaStaticFieldViaImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt"); + doTest(fileName); + } + + @TestMetadata("kt7564.kt") + public void testKt7564() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt"); + doTest(fileName); + } + + @TestMetadata("kt7945_unrelatedClass.kt") + public void testKt7945_unrelatedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt"); + doTest(fileName); + } + + @TestMetadata("localVariable.kt") + public void testLocalVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/localVariable.kt"); + doTest(fileName); + } + + @TestMetadata("memberFromTopLevel.kt") + public void testMemberFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("protectedVarFromClass.kt") + public void testProtectedVarFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/protectedVarFromClass.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeDependentOnGenericProperty.kt") + public void testReturnTypeDependentOnGenericProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/returnTypeDependentOnGenericProperty.kt"); + doTest(fileName); + } + + @TestMetadata("samePriorityForFunctionsAndProperties.kt") + public void testSamePriorityForFunctionsAndProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt"); + doTest(fileName); + } + + @TestMetadata("syntheticProperties.kt") + public void testSyntheticProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/syntheticProperties.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelFromTopLevel.kt") + public void testTopLevelFromTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/callableReference/resolve") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Resolve extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInResolve() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguousWithVararg.kt") + public void testAmbiguousWithVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguousWithVararg.kt"); + doTest(fileName); + } + + @TestMetadata("byArgType.kt") + public void testByArgType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/byArgType.kt"); + doTest(fileName); + } + + @TestMetadata("byGenericArgType.kt") + public void testByGenericArgType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.kt"); + doTest(fileName); + } + + @TestMetadata("byValType.kt") + public void testByValType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/byValType.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("kt10036.kt") + public void testKt10036() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/kt10036.kt"); + doTest(fileName); + } + + @TestMetadata("kt10036_bound.kt") + public void testKt10036_bound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/kt10036_bound.kt"); + doTest(fileName); + } + + @TestMetadata("kt12338.kt") + public void testKt12338() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/kt12338.kt"); + doTest(fileName); + } + + @TestMetadata("kt12751.kt") + public void testKt12751() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/kt12751.kt"); + doTest(fileName); + } + + @TestMetadata("kt8596.kt") + public void testKt8596() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/kt8596.kt"); + doTest(fileName); + } + + @TestMetadata("kt9601.kt") + public void testKt9601() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/kt9601.kt"); + doTest(fileName); + } + + @TestMetadata("moreSpecificAmbiguousExtensions.kt") + public void testMoreSpecificAmbiguousExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificAmbiguousExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("moreSpecificSimple.kt") + public void testMoreSpecificSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificSimple.kt"); + doTest(fileName); + } + + @TestMetadata("noFakeDescriptorForObject.kt") + public void testNoFakeDescriptorForObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt"); + doTest(fileName); + } + + @TestMetadata("overloads.kt") + public void testOverloads() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/overloads.kt"); + doTest(fileName); + } + + @TestMetadata("overloadsBound.kt") + public void testOverloadsBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/overloadsBound.kt"); + doTest(fileName); + } + + @TestMetadata("overloadsMember.kt") + public void testOverloadsMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/overloadsMember.kt"); + doTest(fileName); + } + + @TestMetadata("valVsFun.kt") + public void testValVsFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/valVsFun.kt"); + doTest(fileName); + } + + @TestMetadata("withAs.kt") + public void testWithAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/withAs.kt"); + doTest(fileName); + } + + @TestMetadata("withExtFun.kt") + public void testWithExtFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/withExtFun.kt"); + doTest(fileName); + } + + @TestMetadata("withGenericFun.kt") + public void testWithGenericFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt"); + doTest(fileName); + } + + @TestMetadata("withPlaceholderTypes.kt") + public void testWithPlaceholderTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt"); + doTest(fileName); + } + + @TestMetadata("withVararg.kt") + public void testWithVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/callableReference/resolve/withVararg.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/cast") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Cast extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCast() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AsArray.kt") + public void testAsArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsArray.kt"); + doTest(fileName); + } + + @TestMetadata("AsErasedError.kt") + public void testAsErasedError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsErasedError.kt"); + doTest(fileName); + } + + @TestMetadata("AsErasedFine.kt") + public void testAsErasedFine() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsErasedFine.kt"); + doTest(fileName); + } + + @TestMetadata("AsErasedStar.kt") + public void testAsErasedStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsErasedStar.kt"); + doTest(fileName); + } + + @TestMetadata("AsErasedWarning.kt") + public void testAsErasedWarning() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsErasedWarning.kt"); + doTest(fileName); + } + + @TestMetadata("AsInBinaryUnary.kt") + public void testAsInBinaryUnary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt"); + doTest(fileName); + } + + @TestMetadata("AsInBlockWithReturnType.kt") + public void testAsInBlockWithReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsInBlockWithReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("AsInPropertyAndPropertyAccessor.kt") + public void testAsInPropertyAndPropertyAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsInPropertyAndPropertyAccessor.kt"); + doTest(fileName); + } + + @TestMetadata("AsNothing.kt") + public void testAsNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsNothing.kt"); + doTest(fileName); + } + + @TestMetadata("AsTypeAlias.kt") + public void testAsTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("AsWithOtherParameter.kt") + public void testAsWithOtherParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/AsWithOtherParameter.kt"); + doTest(fileName); + } + + @TestMetadata("checkCastToNullableType.kt") + public void testCheckCastToNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("constants.kt") + public void testConstants() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/constants.kt"); + doTest(fileName); + } + + @TestMetadata("DowncastMap.kt") + public void testDowncastMap() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/DowncastMap.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionAsNonExtension.kt") + public void testExtensionAsNonExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/ExtensionAsNonExtension.kt"); + doTest(fileName); + } + + @TestMetadata("FlexibleTargetType.kt") + public void testFlexibleTargetType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/FlexibleTargetType.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt") + public void testIsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForExactSupertypeCheck.kt") + public void testIsErasedAllowForExactSupertypeCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForExactSupertypeCheck.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForOverridenVarianceWithProjection.kt") + public void testIsErasedAllowForOverridenVarianceWithProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForOverridenVarianceWithProjection.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForSupertypeCheckWithContrvariance.kt") + public void testIsErasedAllowForSupertypeCheckWithContrvariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithContrvariance.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForSupertypeCheckWithCovariance.kt") + public void testIsErasedAllowForSupertypeCheckWithCovariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithCovariance.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForTypeWithIrrelevantMixin.kt") + public void testIsErasedAllowForTypeWithIrrelevantMixin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithIrrelevantMixin.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt") + public void testIsErasedAllowForTypeWithTwoSameTypeSubstitutions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowForTypeWithoutTypeArguments.kt") + public void testIsErasedAllowForTypeWithoutTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithoutTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowFromOut.kt") + public void testIsErasedAllowFromOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowFromOut2.kt") + public void testIsErasedAllowFromOut2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut2.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowFromOutAtClass.kt") + public void testIsErasedAllowFromOutAtClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOutAtClass.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowParameterSubtype.kt") + public void testIsErasedAllowParameterSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowParameterSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowSameClassParameter.kt") + public void testIsErasedAllowSameClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowSameClassParameter.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedAllowSameParameterParameter.kt") + public void testIsErasedAllowSameParameterParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedAllowSameParameterParameter.kt"); + doTest(fileName); + } + + @TestMetadata("isErasedAnyAndStarred.kt") + public void testIsErasedAnyAndStarred() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/isErasedAnyAndStarred.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowDifferentArgInvariantPosition.kt") + public void testIsErasedDisallowDifferentArgInvariantPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowDifferentArgInvariantPosition.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowForOverridenVariance.kt") + public void testIsErasedDisallowForOverridenVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowForOverridenVariance.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowForTypeWithConstraints.kt") + public void testIsErasedDisallowForTypeWithConstraints() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowForTypeWithConstraints.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowFromAny.kt") + public void testIsErasedDisallowFromAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromAny.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowFromIn.kt") + public void testIsErasedDisallowFromIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromIn.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowFromOut.kt") + public void testIsErasedDisallowFromOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromOut.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDisallowFromOutAtClass.kt") + public void testIsErasedDisallowFromOutAtClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromOutAtClass.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt") + public void testIsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt") + public void testIsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedNonGeneric.kt") + public void testIsErasedNonGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedNonGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedNullableTasT.kt") + public void testIsErasedNullableTasT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedNullableTasT.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedStar.kt") + public void testIsErasedStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedStar.kt"); + doTest(fileName); + } + + @TestMetadata("isErasedTAndStarred.kt") + public void testIsErasedTAndStarred() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/isErasedTAndStarred.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedTasT.kt") + public void testIsErasedTasT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedTasT.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedToErrorType.kt") + public void testIsErasedToErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedToErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("isErasedUnrelatedAndStarred.kt") + public void testIsErasedUnrelatedAndStarred() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/isErasedUnrelatedAndStarred.kt"); + doTest(fileName); + } + + @TestMetadata("IsErasedUpcastToNonReified.kt") + public void testIsErasedUpcastToNonReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsErasedUpcastToNonReified.kt"); + doTest(fileName); + } + + @TestMetadata("IsForTypeWithComplexUpperBound.kt") + public void testIsForTypeWithComplexUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsForTypeWithComplexUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("IsRecursionSustainable.kt") + public void testIsRecursionSustainable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsRecursionSustainable.kt"); + doTest(fileName); + } + + @TestMetadata("IsTraits.kt") + public void testIsTraits() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsTraits.kt"); + doTest(fileName); + } + + @TestMetadata("IsWithCycleUpperBounds.kt") + public void testIsWithCycleUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/IsWithCycleUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("kt15161.kt") + public void testKt15161() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/kt15161.kt"); + doTest(fileName); + } + + @TestMetadata("kt614.kt") + public void testKt614() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/kt614.kt"); + doTest(fileName); + } + + @TestMetadata("NullableToNullable.kt") + public void testNullableToNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/NullableToNullable.kt"); + doTest(fileName); + } + + @TestMetadata("StableTypeForUselessCast.kt") + public void testStableTypeForUselessCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/StableTypeForUselessCast.kt"); + doTest(fileName); + } + + @TestMetadata("UselessSafeCast.kt") + public void testUselessSafeCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/UselessSafeCast.kt"); + doTest(fileName); + } + + @TestMetadata("WhenErasedDisallowFromAny.kt") + public void testWhenErasedDisallowFromAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/WhenErasedDisallowFromAny.kt"); + doTest(fileName); + } + + @TestMetadata("WhenWithExpression.kt") + public void testWhenWithExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/WhenWithExpression.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/cast/bare") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Bare extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInBare() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AsNestedBare.kt") + public void testAsNestedBare() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/AsNestedBare.kt"); + doTest(fileName); + } + + @TestMetadata("AsNullable.kt") + public void testAsNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/AsNullable.kt"); + doTest(fileName); + } + + @TestMetadata("AsNullableNotEnough.kt") + public void testAsNullableNotEnough() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.kt"); + doTest(fileName); + } + + @TestMetadata("EitherAs.kt") + public void testEitherAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/EitherAs.kt"); + doTest(fileName); + } + + @TestMetadata("EitherIs.kt") + public void testEitherIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/EitherIs.kt"); + doTest(fileName); + } + + @TestMetadata("EitherNotIs.kt") + public void testEitherNotIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/EitherNotIs.kt"); + doTest(fileName); + } + + @TestMetadata("EitherSafeAs.kt") + public void testEitherSafeAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/EitherSafeAs.kt"); + doTest(fileName); + } + + @TestMetadata("EitherWhen.kt") + public void testEitherWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/EitherWhen.kt"); + doTest(fileName); + } + + @TestMetadata("ErrorsInSubstitution.kt") + public void testErrorsInSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/ErrorsInSubstitution.kt"); + doTest(fileName); + } + + @TestMetadata("FromErrorType.kt") + public void testFromErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/FromErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("NullableAs.kt") + public void testNullableAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/NullableAs.kt"); + doTest(fileName); + } + + @TestMetadata("NullableAsNotEnough.kt") + public void testNullableAsNotEnough() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.kt"); + doTest(fileName); + } + + @TestMetadata("NullableAsNullable.kt") + public void testNullableAsNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/NullableAsNullable.kt"); + doTest(fileName); + } + + @TestMetadata("NullableAsNullableNotEnough.kt") + public void testNullableAsNullableNotEnough() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.kt"); + doTest(fileName); + } + + @TestMetadata("RedundantNullable.kt") + public void testRedundantNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/RedundantNullable.kt"); + doTest(fileName); + } + + @TestMetadata("ToErrorType.kt") + public void testToErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/ToErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("UnrelatedAs.kt") + public void testUnrelatedAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.kt"); + doTest(fileName); + } + + @TestMetadata("UnrelatedColon.kt") + public void testUnrelatedColon() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.kt"); + doTest(fileName); + } + + @TestMetadata("UnrelatedIs.kt") + public void testUnrelatedIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/bare/UnrelatedIs.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NeverSucceeds extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNeverSucceeds() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("CastToNotNullSuper.kt") + public void testCastToNotNullSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds/CastToNotNullSuper.kt"); + doTest(fileName); + } + + @TestMetadata("MappedDirect.kt") + public void testMappedDirect() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds/MappedDirect.kt"); + doTest(fileName); + } + + @TestMetadata("MappedSubtypes.kt") + public void testMappedSubtypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds/MappedSubtypes.kt"); + doTest(fileName); + } + + @TestMetadata("NoGenericsRelated.kt") + public void testNoGenericsRelated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds/NoGenericsRelated.kt"); + doTest(fileName); + } + + @TestMetadata("NoGenericsUnrelated.kt") + public void testNoGenericsUnrelated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds/NoGenericsUnrelated.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/checkArguments") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CheckArguments extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCheckArguments() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayAccessSet.kt") + public void testArrayAccessSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.kt"); + doTest(fileName); + } + + @TestMetadata("arrayAccessSetTooManyArgs.kt") + public void testArrayAccessSetTooManyArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.kt"); + doTest(fileName); + } + + @TestMetadata("booleanExpressions.kt") + public void testBooleanExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("kt1897_diagnostic_part.kt") + public void testKt1897_diagnostic_part() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt"); + doTest(fileName); + } + + @TestMetadata("kt1940.kt") + public void testKt1940() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/kt1940.kt"); + doTest(fileName); + } + + @TestMetadata("overloadedFunction.kt") + public void testOverloadedFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.kt"); + doTest(fileName); + } + + @TestMetadata("SpreadVarargs.kt") + public void testSpreadVarargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/classLiteral") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassLiteral extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInClassLiteral() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrays.kt") + public void testArrays() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/arrays.kt"); + doTest(fileName); + } + + @TestMetadata("classAndObjectLiteralType.kt") + public void testClassAndObjectLiteralType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/classAndObjectLiteralType.kt"); + doTest(fileName); + } + + @TestMetadata("classLiteralType.kt") + public void testClassLiteralType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt"); + doTest(fileName); + } + + @TestMetadata("expressionWithNullableType.kt") + public void testExpressionWithNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("genericArrays.kt") + public void testGenericArrays() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/genericArrays.kt"); + doTest(fileName); + } + + @TestMetadata("genericClasses.kt") + public void testGenericClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/genericClasses.kt"); + doTest(fileName); + } + + @TestMetadata("inAnnotationArguments.kt") + public void testInAnnotationArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt"); + doTest(fileName); + } + + @TestMetadata("integerValueType.kt") + public void testIntegerValueType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/integerValueType.kt"); + doTest(fileName); + } + + @TestMetadata("nonClassesOnLHS.kt") + public void testNonClassesOnLHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/nonClassesOnLHS.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedClassLiteral.kt") + public void testQualifiedClassLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/qualifiedClassLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("simpleClassLiteral.kt") + public void testSimpleClassLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/simpleClassLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("smartCast.kt") + public void testSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/smartCast.kt"); + doTest(fileName); + } + + @TestMetadata("typealiases.kt") + public void testTypealiases() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/typealiases.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedClass.kt") + public void testUnresolvedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/classObjects") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassObjects extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInClassObjects() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("builtInClassObjects.kt") + public void testBuiltInClassObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/builtInClassObjects.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectCannotAccessClassFields.kt") + public void testClassObjectCannotAccessClassFields() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/ClassObjectCannotAccessClassFields.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectHeader.kt") + public void testClassObjectHeader() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/classObjectHeader.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectInLocalClass.kt") + public void testClassObjectInLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectRedeclaration.kt") + public void testClassObjectRedeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/classObjectRedeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectVisibility.kt") + public void testClassObjectVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjects.kt") + public void testClassObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectOfPrivateClassVisibility.kt") + public void testCompanionObjectOfPrivateClassVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/companionObjectOfPrivateClassVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("importClassInClassObject.kt") + public void testImportClassInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/importClassInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassAccessThroughClassObject.kt") + public void testInnerClassAccessThroughClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassAccessThroughEnum.kt") + public void testInnerClassAccessThroughEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassClassObject.kt") + public void testInnerClassClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("invisibleClassObjects.kt") + public void testInvisibleClassObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt"); + doTest(fileName); + } + + @TestMetadata("kt3866.kt") + public void testKt3866() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/kt3866.kt"); + doTest(fileName); + } + + @TestMetadata("multipleDissallowedDefaultObjects.kt") + public void testMultipleDissallowedDefaultObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassInPrivateClassObject.kt") + public void testNestedClassInPrivateClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("resolveFunctionInsideClassObject.kt") + public void testResolveFunctionInsideClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/resolveFunctionInsideClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("typeParametersInObject.kt") + public void testTypeParametersInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/classObjects/typeParametersInObject.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/collectionLiterals") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CollectionLiterals extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCollectionLiterals() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("argumentsOfAnnotation.kt") + public void testArgumentsOfAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("argumentsOfAnnotationWithKClass.kt") + public void testArgumentsOfAnnotationWithKClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt"); + doTest(fileName); + } + + @TestMetadata("basicCollectionLiterals.kt") + public void testBasicCollectionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("collectionLiteralsAsPrimitiveArrays.kt") + public void testCollectionLiteralsAsPrimitiveArrays() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsAsPrimitiveArrays.kt"); + doTest(fileName); + } + + @TestMetadata("collectionLiteralsWithVarargs.kt") + public void testCollectionLiteralsWithVarargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt"); + doTest(fileName); + } + + @TestMetadata("defaultValuesInAnnotation.kt") + public void testDefaultValuesInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("defaultValuesWithConstantsInAnnotation.kt") + public void testDefaultValuesWithConstantsInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesWithConstantsInAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("noArrayLiteralsInAnnotationsFeature.kt") + public void testNoArrayLiteralsInAnnotationsFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/noArrayLiteralsInAnnotationsFeature.kt"); + doTest(fileName); + } + + @TestMetadata("noCollectionLiterals.kt") + public void testNoCollectionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("resolveToFunctionFromBuiltIns.kt") + public void testResolveToFunctionFromBuiltIns() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/collectionLiterals/resolveToFunctionFromBuiltIns.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/constructorConsistency") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ConstructorConsistency extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("afterInitialization.kt") + public void testAfterInitialization() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/afterInitialization.kt"); + doTest(fileName); + } + + @TestMetadata("aliencall.kt") + public void testAliencall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/aliencall.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInConstructorConsistency() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("backing.kt") + public void testBacking() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/backing.kt"); + doTest(fileName); + } + + @TestMetadata("basic.kt") + public void testBasic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/basic.kt"); + doTest(fileName); + } + + @TestMetadata("companion.kt") + public void testCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/companion.kt"); + doTest(fileName); + } + + @TestMetadata("comparison.kt") + public void testComparison() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/comparison.kt"); + doTest(fileName); + } + + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/delegate.kt"); + doTest(fileName); + } + + @TestMetadata("derived.kt") + public void testDerived() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/derived.kt"); + doTest(fileName); + } + + @TestMetadata("derivedProperty.kt") + public void testDerivedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("getset.kt") + public void testGetset() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/getset.kt"); + doTest(fileName); + } + + @TestMetadata("init.kt") + public void testInit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/init.kt"); + doTest(fileName); + } + + @TestMetadata("initializerWithSecondaryConstructor.kt") + public void testInitializerWithSecondaryConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("initwithgetter.kt") + public void testInitwithgetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt"); + doTest(fileName); + } + + @TestMetadata("inspection.kt") + public void testInspection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaInObject.kt") + public void testLambdaInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/lambdaInObject.kt"); + doTest(fileName); + } + + @TestMetadata("lateInit.kt") + public void testLateInit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt"); + doTest(fileName); + } + + @TestMetadata("localObject.kt") + public void testLocalObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/localObject.kt"); + doTest(fileName); + } + + @TestMetadata("multipleAreNull.kt") + public void testMultipleAreNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/multipleAreNull.kt"); + doTest(fileName); + } + + @TestMetadata("nobacking.kt") + public void testNobacking() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt"); + doTest(fileName); + } + + @TestMetadata("open.kt") + public void testOpen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/open.kt"); + doTest(fileName); + } + + @TestMetadata("openProperty.kt") + public void testOpenProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/openProperty.kt"); + doTest(fileName); + } + + @TestMetadata("outer.kt") + public void testOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/outer.kt"); + doTest(fileName); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/property.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAccess.kt") + public void testPropertyAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/propertyAccess.kt"); + doTest(fileName); + } + + @TestMetadata("twoSecondaryConstructors.kt") + public void testTwoSecondaryConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/constructorConsistency/twoSecondaryConstructors.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ControlFlowAnalysis extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInControlFlowAnalysis() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignedInFinally.kt") + public void testAssignedInFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInFinally.kt"); + doTest(fileName); + } + + @TestMetadata("assignmentInLocalsInConstructor.kt") + public void testAssignmentInLocalsInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("backingFieldInsideGetter.kt") + public void testBackingFieldInsideGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter.kt"); + doTest(fileName); + } + + @TestMetadata("breakContinueInTryFinally.kt") + public void testBreakContinueInTryFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakContinueInTryFinally.kt"); + doTest(fileName); + } + + @TestMetadata("breakInsideLocal.kt") + public void testBreakInsideLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakInsideLocal.kt"); + doTest(fileName); + } + + @TestMetadata("breakOrContinueInLoopCondition.kt") + public void testBreakOrContinueInLoopCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakOrContinueInLoopCondition.kt"); + doTest(fileName); + } + + @TestMetadata("checkInnerLocalDeclarations.kt") + public void testCheckInnerLocalDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/checkInnerLocalDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("checkPropertyAccessor.kt") + public void testCheckPropertyAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/checkPropertyAccessor.kt"); + doTest(fileName); + } + + @TestMetadata("constructorPropertyInterdependence.kt") + public void testConstructorPropertyInterdependence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/constructorPropertyInterdependence.kt"); + doTest(fileName); + } + + @TestMetadata("definiteReturnInWhen.kt") + public void testDefiniteReturnInWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturnInWhen.kt"); + doTest(fileName); + } + + @TestMetadata("delegatedPropertyEarlyAccess.kt") + public void testDelegatedPropertyEarlyAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileAssignment.kt") + public void testDoWhileAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/doWhileAssignment.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileNotDefined.kt") + public void testDoWhileNotDefined() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/doWhileNotDefined.kt"); + doTest(fileName); + } + + @TestMetadata("elvisNotProcessed.kt") + public void testElvisNotProcessed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt"); + doTest(fileName); + } + + @TestMetadata("enumCompanionInterdependence.kt") + public void testEnumCompanionInterdependence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.kt"); + doTest(fileName); + } + + @TestMetadata("enumInterdependence.kt") + public void testEnumInterdependence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/enumInterdependence.kt"); + doTest(fileName); + } + + @TestMetadata("fieldAsClassDelegate.kt") + public void testFieldAsClassDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("infiniteLoops.kt") + public void testInfiniteLoops() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/infiniteLoops.kt"); + doTest(fileName); + } + + @TestMetadata("initializationInLambda.kt") + public void testInitializationInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("initializationInLocalClass.kt") + public void testInitializationInLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("initializationInLocalFun.kt") + public void testInitializationInLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalFun.kt"); + doTest(fileName); + } + + @TestMetadata("initializationInLocalViaExplicitThis.kt") + public void testInitializationInLocalViaExplicitThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis.kt"); + doTest(fileName); + } + + @TestMetadata("kt1001.kt") + public void testKt1001() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1001.kt"); + doTest(fileName); + } + + @TestMetadata("kt1027.kt") + public void testKt1027() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1027.kt"); + doTest(fileName); + } + + @TestMetadata("kt1066.kt") + public void testKt1066() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1066.kt"); + doTest(fileName); + } + + @TestMetadata("kt10805.kt") + public void testKt10805() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt"); + doTest(fileName); + } + + @TestMetadata("kt10823.kt") + public void testKt10823() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10823.kt"); + doTest(fileName); + } + + @TestMetadata("kt1156.kt") + public void testKt1156() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1156.kt"); + doTest(fileName); + } + + @TestMetadata("kt1185enums.kt") + public void testKt1185enums() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1185enums.kt"); + doTest(fileName); + } + + @TestMetadata("kt1189.kt") + public void testKt1189() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.kt"); + doTest(fileName); + } + + @TestMetadata("kt1191.kt") + public void testKt1191() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1191.kt"); + doTest(fileName); + } + + @TestMetadata("kt1219.1301.kt") + public void testKt1219_1301() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1219.1301.kt"); + doTest(fileName); + } + + @TestMetadata("kt1571.kt") + public void testKt1571() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1571.kt"); + doTest(fileName); + } + + @TestMetadata("kt1977.kt") + public void testKt1977() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1977.kt"); + doTest(fileName); + } + + @TestMetadata("kt2166_kt2103.kt") + public void testKt2166_kt2103() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2166_kt2103.kt"); + doTest(fileName); + } + + @TestMetadata("kt2226.kt") + public void testKt2226() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2226.kt"); + doTest(fileName); + } + + @TestMetadata("kt2330.kt") + public void testKt2330() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt"); + doTest(fileName); + } + + @TestMetadata("kt2334.kt") + public void testKt2334() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2334.kt"); + doTest(fileName); + } + + @TestMetadata("kt2369.kt") + public void testKt2369() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2369.kt"); + doTest(fileName); + } + + @TestMetadata("kt2845.kt") + public void testKt2845() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2845.kt"); + doTest(fileName); + } + + @TestMetadata("kt2960.kt") + public void testKt2960() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2960.kt"); + doTest(fileName); + } + + @TestMetadata("kt2972.kt") + public void testKt2972() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.kt"); + doTest(fileName); + } + + @TestMetadata("kt3444.kt") + public void testKt3444() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt3444.kt"); + doTest(fileName); + } + + @TestMetadata("kt3501.kt") + public void testKt3501() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt3501.kt"); + doTest(fileName); + } + + @TestMetadata("kt4126.kt") + public void testKt4126() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.kt"); + doTest(fileName); + } + + @TestMetadata("kt4405.kt") + public void testKt4405() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt"); + doTest(fileName); + } + + @TestMetadata("kt510.kt") + public void testKt510() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt"); + doTest(fileName); + } + + @TestMetadata("kt607.kt") + public void testKt607() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt607.kt"); + doTest(fileName); + } + + @TestMetadata("kt609.kt") + public void testKt609() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt609.kt"); + doTest(fileName); + } + + @TestMetadata("kt610.kt") + public void testKt610() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt610.kt"); + doTest(fileName); + } + + @TestMetadata("kt6788.kt") + public void testKt6788() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt"); + doTest(fileName); + } + + @TestMetadata("kt776.kt") + public void testKt776() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt776.kt"); + doTest(fileName); + } + + @TestMetadata("kt843.kt") + public void testKt843() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt843.kt"); + doTest(fileName); + } + + @TestMetadata("kt897.kt") + public void testKt897() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt"); + doTest(fileName); + } + + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/localClasses.kt"); + doTest(fileName); + } + + @TestMetadata("localObjectInConstructor.kt") + public void testLocalObjectInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/localObjectInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("nestedTryFinally.kt") + public void testNestedTryFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/nestedTryFinally.kt"); + doTest(fileName); + } + + @TestMetadata("nonLocalReturnUnreachable.kt") + public void testNonLocalReturnUnreachable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt"); + doTest(fileName); + } + + @TestMetadata("nonLocalReturnWithFinally.kt") + public void testNonLocalReturnWithFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnWithFinally.kt"); + doTest(fileName); + } + + @TestMetadata("privateSetter.kt") + public void testPrivateSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/privateSetter.kt"); + doTest(fileName); + } + + @TestMetadata("propertiesInitWithOtherInstance.kt") + public void testPropertiesInitWithOtherInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt"); + doTest(fileName); + } + + @TestMetadata("propertiesInitWithOtherInstanceInner.kt") + public void testPropertiesInitWithOtherInstanceInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt"); + doTest(fileName); + } + + @TestMetadata("propertiesInitWithOtherInstanceThisLabel.kt") + public void testPropertiesInitWithOtherInstanceThisLabel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt"); + doTest(fileName); + } + + @TestMetadata("propertiesOrderInPackage.kt") + public void testPropertiesOrderInPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesOrderInPackage.kt"); + doTest(fileName); + } + + @TestMetadata("reassignmentInTryCatch.kt") + public void testReassignmentInTryCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/reassignmentInTryCatch.kt"); + doTest(fileName); + } + + @TestMetadata("reassignmentInTryCatchWithJumps.kt") + public void testReassignmentInTryCatchWithJumps() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/reassignmentInTryCatchWithJumps.kt"); + doTest(fileName); + } + + @TestMetadata("referenceToPropertyInitializer.kt") + public void testReferenceToPropertyInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("repeatUnitializedErrorOnlyForLocalVars.kt") + public void testRepeatUnitializedErrorOnlyForLocalVars() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt"); + doTest(fileName); + } + + @TestMetadata("scopeOfAnonymousInitializer.kt") + public void testScopeOfAnonymousInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("throwInLambda.kt") + public void testThrowInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("tryWithAssignmentUsedInCatch.kt") + public void testTryWithAssignmentUsedInCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/tryWithAssignmentUsedInCatch.kt"); + doTest(fileName); + } + + @TestMetadata("uninitializedInLocalDeclarations.kt") + public void testUninitializedInLocalDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedInLocalDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("UninitializedOrReassignedVariables.kt") + public void testUninitializedOrReassignedVariables() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt"); + doTest(fileName); + } + + @TestMetadata("unmappedArgs.kt") + public void testUnmappedArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedReference.kt") + public void testUnresolvedReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unresolvedReference.kt"); + doTest(fileName); + } + + @TestMetadata("unusedInAnonymous.kt") + public void testUnusedInAnonymous() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unusedInAnonymous.kt"); + doTest(fileName); + } + + @TestMetadata("useUninitializedInLambda.kt") + public void testUseUninitializedInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/useUninitializedInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("varInitializationInIfInCycle.kt") + public void testVarInitializationInIfInCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/varInitializationInIfInCycle.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DeadCode extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDeadCode() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("commasAndWhitespaces.kt") + public void testCommasAndWhitespaces() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/commasAndWhitespaces.kt"); + doTest(fileName); + } + + @TestMetadata("commentsInDeadCode.kt") + public void testCommentsInDeadCode() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/commentsInDeadCode.kt"); + doTest(fileName); + } + + @TestMetadata("deadCallInInvokeCall.kt") + public void testDeadCallInInvokeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCallInInvokeCall.kt"); + doTest(fileName); + } + + @TestMetadata("deadCallInReceiver.kt") + public void testDeadCallInReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCallInReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeDifferentExamples.kt") + public void testDeadCodeDifferentExamples() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeDifferentExamples.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeFromDifferentSources.kt") + public void testDeadCodeFromDifferentSources() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeFromDifferentSources.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInArrayAccess.kt") + public void testDeadCodeInArrayAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInArrayAccess.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInAssignment.kt") + public void testDeadCodeInAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInAssignment.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInBinaryExpressions.kt") + public void testDeadCodeInBinaryExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInCalls.kt") + public void testDeadCodeInCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInCalls.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInDeadCode.kt") + public void testDeadCodeInDeadCode() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInDeadCode.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInIf.kt") + public void testDeadCodeInIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInIf.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInInnerExpressions.kt") + public void testDeadCodeInInnerExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInInnerExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInLocalDeclarations.kt") + public void testDeadCodeInLocalDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInLoops.kt") + public void testDeadCodeInLoops() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLoops.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInReturn.kt") + public void testDeadCodeInReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInReturn.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInUnaryExpr.kt") + public void testDeadCodeInUnaryExpr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInUnaryExpr.kt"); + doTest(fileName); + } + + @TestMetadata("deadCodeInWhileFromBreak.kt") + public void testDeadCodeInWhileFromBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt"); + doTest(fileName); + } + + @TestMetadata("expressionInUnitLiteral.kt") + public void testExpressionInUnitLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/expressionInUnitLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("kt2585_1.kt") + public void testKt2585_1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_1.kt"); + doTest(fileName); + } + + @TestMetadata("kt2585_2.kt") + public void testKt2585_2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_2.kt"); + doTest(fileName); + } + + @TestMetadata("kt2585_3.kt") + public void testKt2585_3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_3.kt"); + doTest(fileName); + } + + @TestMetadata("kt3162tryAsInitializer.kt") + public void testKt3162tryAsInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt3162tryAsInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("kt5200DeadCodeInLambdas.kt") + public void testKt5200DeadCodeInLambdas() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefiniteReturn extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDefiniteReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt3444_ReturnFromLocalFunctions.kt") + public void testKt3444_ReturnFromLocalFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/kt3444_ReturnFromLocalFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("kt4034.kt") + public void testKt4034() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/kt4034.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnFromFunctionInObject.kt") + public void testReturnFromFunctionInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/ReturnFromFunctionInObject.kt"); + doTest(fileName); + } + + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/simpleClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class UnnecessaryLateinit extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("lateinitRecursiveInLambda.kt") + public void testLateinitRecursiveInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithConstructor.kt") + public void testLateinitWithConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithErroneousDelegation.kt") + public void testLateinitWithErroneousDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithInit.kt") + public void testLateinitWithInit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithMultipleConstructors.kt") + public void testLateinitWithMultipleConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithMultipleConstructorsAndDelegation.kt") + public void testLateinitWithMultipleConstructorsAndDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithPlusAssign.kt") + public void testLateinitWithPlusAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPlusAssign.kt"); + doTest(fileName); + } + + @TestMetadata("lateinitWithPrimaryConstructorAndConstructor.kt") + public void testLateinitWithPrimaryConstructorAndConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("normalLateinit.kt") + public void testNormalLateinit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/normalLateinit.kt"); + doTest(fileName); + } + + @TestMetadata("normalLateinitWithTwoConstructors.kt") + public void testNormalLateinitWithTwoConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/normalLateinitWithTwoConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("secondaryConstructorDelegateItself.kt") + public void testSecondaryConstructorDelegateItself() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/secondaryConstructorDelegateItself.kt"); + doTest(fileName); + } + + @TestMetadata("secondaryConstructorDelegateLoop.kt") + public void testSecondaryConstructorDelegateLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/secondaryConstructorDelegateLoop.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/controlStructures") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ControlStructures extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInControlStructures() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("catchGenerics.kt") + public void testCatchGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("catchWithDefault.kt") + public void testCatchWithDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/catchWithDefault.kt"); + doTest(fileName); + } + + @TestMetadata("commonSupertypeOfT.kt") + public void testCommonSupertypeOfT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/commonSupertypeOfT.kt"); + doTest(fileName); + } + + @TestMetadata("continueAndBreakLabelWithSameFunctionName.kt") + public void testContinueAndBreakLabelWithSameFunctionName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/continueAndBreakLabelWithSameFunctionName.kt"); + doTest(fileName); + } + + @TestMetadata("emptyIf.kt") + public void testEmptyIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt"); + doTest(fileName); + } + + @TestMetadata("ForLoopWithExtensionIteratorOnNullable.kt") + public void testForLoopWithExtensionIteratorOnNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ForLoopWithExtensionIteratorOnNullable.kt"); + doTest(fileName); + } + + @TestMetadata("forLoopWithNullableRange.kt") + public void testForLoopWithNullableRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt"); + doTest(fileName); + } + + @TestMetadata("forWithNullableIterator.kt") + public void testForWithNullableIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/forWithNullableIterator.kt"); + doTest(fileName); + } + + @TestMetadata("ForWithoutBraces.kt") + public void testForWithoutBraces() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ForWithoutBraces.kt"); + doTest(fileName); + } + + @TestMetadata("ForbidStatementAsDirectFunctionBody.kt") + public void testForbidStatementAsDirectFunctionBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ForbidStatementAsDirectFunctionBody.kt"); + doTest(fileName); + } + + @TestMetadata("ifElseIntersection.kt") + public void testIfElseIntersection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt"); + doTest(fileName); + } + + @TestMetadata("ifInResultOfLambda.kt") + public void testIfInResultOfLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt"); + doTest(fileName); + } + + @TestMetadata("ifToAnyDiscriminatingUsages.kt") + public void testIfToAnyDiscriminatingUsages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt"); + doTest(fileName); + } + + @TestMetadata("ifWhenToAnyComplexExpressions.kt") + public void testIfWhenToAnyComplexExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("ifWhenWithoutElse.kt") + public void testIfWhenWithoutElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt"); + doTest(fileName); + } + + @TestMetadata("improperElseInExpression.kt") + public void testImproperElseInExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt"); + doTest(fileName); + } + + @TestMetadata("jumpAcrossFunctionBoundary.kt") + public void testJumpAcrossFunctionBoundary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/jumpAcrossFunctionBoundary.kt"); + doTest(fileName); + } + + @TestMetadata("kt10322.kt") + public void testKt10322() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt10322.kt"); + doTest(fileName); + } + + @TestMetadata("kt10706.kt") + public void testKt10706() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt10706.kt"); + doTest(fileName); + } + + @TestMetadata("kt10717.kt") + public void testKt10717() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt10717.kt"); + doTest(fileName); + } + + @TestMetadata("kt1075.kt") + public void testKt1075() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt1075.kt"); + doTest(fileName); + } + + @TestMetadata("kt4310.kt") + public void testKt4310() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt4310.kt"); + doTest(fileName); + } + + @TestMetadata("kt657.kt") + public void testKt657() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt657.kt"); + doTest(fileName); + } + + @TestMetadata("kt770.kt351.kt735_StatementType.kt") + public void testKt770_kt351_kt735_StatementType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt"); + doTest(fileName); + } + + @TestMetadata("kt786.kt") + public void testKt786() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt786.kt"); + doTest(fileName); + } + + @TestMetadata("kt799.kt") + public void testKt799() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/kt799.kt"); + doTest(fileName); + } + + @TestMetadata("lambdasInExclExclAndElvis.kt") + public void testLambdasInExclExclAndElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt"); + doTest(fileName); + } + + @TestMetadata("localReturnInsidePropertyAccessor.kt") + public void testLocalReturnInsidePropertyAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt"); + doTest(fileName); + } + + @TestMetadata("specialConstructsAndPlatformTypes.kt") + public void testSpecialConstructsAndPlatformTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt"); + doTest(fileName); + } + + @TestMetadata("specialConstructsWithNullableExpectedType.kt") + public void testSpecialConstructsWithNullableExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/specialConstructsWithNullableExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("tryReturnType.kt") + public void testTryReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("typeInferenceForExclExcl.kt") + public void testTypeInferenceForExclExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt"); + doTest(fileName); + } + + @TestMetadata("valVarCatchParameter.kt") + public void testValVarCatchParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/valVarCatchParameter.kt"); + doTest(fileName); + } + + @TestMetadata("valVarLoopParameter.kt") + public void testValVarLoopParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/valVarLoopParameter.kt"); + doTest(fileName); + } + + @TestMetadata("whenInResultOfLambda.kt") + public void testWhenInResultOfLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt"); + doTest(fileName); + } + + @TestMetadata("whenToAnyDiscriminatingUsages.kt") + public void testWhenToAnyDiscriminatingUsages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/whenToAnyDiscriminatingUsages.kt"); + doTest(fileName); + } + + @TestMetadata("when.kt234.kt973.kt") + public void testWhen_kt234_kt973() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CyclicHierarchy extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCyclicHierarchy() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classIndirectlyInheritsNested.kt") + public void testClassIndirectlyInheritsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/classIndirectlyInheritsNested.kt"); + doTest(fileName); + } + + @TestMetadata("classInheritsNested.kt") + public void testClassInheritsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/classInheritsNested.kt"); + doTest(fileName); + } + + @TestMetadata("cyclicHierarchy.kt") + public void testCyclicHierarchy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/cyclicHierarchy.kt"); + doTest(fileName); + } + + @TestMetadata("javaJavaCycle.kt") + public void testJavaJavaCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/javaJavaCycle.kt"); + doTest(fileName); + } + + @TestMetadata("javaJavaNested.kt") + public void testJavaJavaNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/javaJavaNested.kt"); + doTest(fileName); + } + + @TestMetadata("javaKotlinJavaCycle.kt") + public void testJavaKotlinJavaCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/javaKotlinJavaCycle.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinJavaCycle.kt") + public void testKotlinJavaCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaCycle.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinJavaKotlinCycle.kt") + public void testKotlinJavaKotlinCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinJavaNestedCycle.kt") + public void testKotlinJavaNestedCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt"); + doTest(fileName); + } + + @TestMetadata("kt303.kt") + public void testKt303() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassInSuperClassParameter.kt") + public void testNestedClassInSuperClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/nestedClassInSuperClassParameter.kt"); + doTest(fileName); + } + + @TestMetadata("twoClassesWithNestedCycle.kt") + public void testTwoClassesWithNestedCycle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/twoClassesWithNestedCycle.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/dataClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DataClasses extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDataClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("componentNamedComponent1.kt") + public void testComponentNamedComponent1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingCopyOverloads.kt") + public void testConflictingCopyOverloads() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingOverloads.kt") + public void testConflictingOverloads() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.kt"); + doTest(fileName); + } + + @TestMetadata("copyOfPrivateClass.kt") + public void testCopyOfPrivateClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.kt"); + doTest(fileName); + } + + @TestMetadata("dataClassNoName.kt") + public void testDataClassNoName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.kt"); + doTest(fileName); + } + + @TestMetadata("dataClassVarargParam.kt") + public void testDataClassVarargParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt"); + doTest(fileName); + } + + @TestMetadata("dataInheritance.kt") + public void testDataInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/dataInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("dataObject.kt") + public void testDataObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/dataObject.kt"); + doTest(fileName); + } + + @TestMetadata("emptyConstructor.kt") + public void testEmptyConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("errorTypesInDataClasses.kt") + public void testErrorTypesInDataClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/errorTypesInDataClasses.kt"); + doTest(fileName); + } + + @TestMetadata("extensionComponentsOnNullable.kt") + public void testExtensionComponentsOnNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt"); + doTest(fileName); + } + + @TestMetadata("finalMembersInBaseClass.kt") + public void testFinalMembersInBaseClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/finalMembersInBaseClass.kt"); + doTest(fileName); + } + + @TestMetadata("implementMethodsFromInterface.kt") + public void testImplementMethodsFromInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/implementMethodsFromInterface.kt"); + doTest(fileName); + } + + @TestMetadata("implementTraitWhichHasComponent1.kt") + public void testImplementTraitWhichHasComponent1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.kt"); + doTest(fileName); + } + + @TestMetadata("implementTraitWhichHasFinalComponent1.kt") + public void testImplementTraitWhichHasFinalComponent1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.kt"); + doTest(fileName); + } + + @TestMetadata("innerDataClass.kt") + public void testInnerDataClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/innerDataClass.kt"); + doTest(fileName); + } + + @TestMetadata("innerOuterDataClass.kt") + public void testInnerOuterDataClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.kt"); + doTest(fileName); + } + + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("multiDeclarationFor.kt") + public void testMultiDeclarationFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.kt"); + doTest(fileName); + } + + @TestMetadata("noConstructor.kt") + public void testNoConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/noConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("notADataClass.kt") + public void testNotADataClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/notADataClass.kt"); + doTest(fileName); + } + + @TestMetadata("oneValParam.kt") + public void testOneValParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/oneValParam.kt"); + doTest(fileName); + } + + @TestMetadata("repeatedProperties.kt") + public void testRepeatedProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.kt"); + doTest(fileName); + } + + @TestMetadata("sealedDataClass.kt") + public void testSealedDataClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.kt"); + doTest(fileName); + } + + @TestMetadata("strange.kt") + public void testStrange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/strange.kt"); + doTest(fileName); + } + + @TestMetadata("twoValParams.kt") + public void testTwoValParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/twoValParams.kt"); + doTest(fileName); + } + + @TestMetadata("twoVarParams.kt") + public void testTwoVarParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataClasses/twoVarParams.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/dataFlow") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DataFlow extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDataFlow() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("CalleeExpression.kt") + public void testCalleeExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/CalleeExpression.kt"); + doTest(fileName); + } + + @TestMetadata("EmptyIf.kt") + public void testEmptyIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt"); + doTest(fileName); + } + + @TestMetadata("IsExpression.kt") + public void testIsExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt"); + doTest(fileName); + } + + @TestMetadata("WhenSubject.kt") + public void testWhenSubject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/WhenSubject.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Assignment extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInAssignment() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignToNewVal.kt") + public void testAssignToNewVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment/assignToNewVal.kt"); + doTest(fileName); + } + + @TestMetadata("kt6118.kt") + public void testKt6118() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment/kt6118.kt"); + doTest(fileName); + } + + @TestMetadata("uninitializedValIsCheck.kt") + public void testUninitializedValIsCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValIsCheck.kt"); + doTest(fileName); + } + + @TestMetadata("uninitializedValNullability.kt") + public void testUninitializedValNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValNullability.kt"); + doTest(fileName); + } + + @TestMetadata("when.kt") + public void testWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment/when.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/dataFlow/local") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Local extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInLocal() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt2835.kt") + public void testKt2835() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/kt2835.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassBase.kt") + public void testLocalClassBase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassBase.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassDefaultParameters.kt") + public void testLocalClassDefaultParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDefaultParameters.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassDelegatedProperties.kt") + public void testLocalClassDelegatedProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDelegatedProperties.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassDelegation.kt") + public void testLocalClassDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassFunctions.kt") + public void testLocalClassFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassInMemberOfLocalClass.kt") + public void testLocalClassInMemberOfLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInMemberOfLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassInitializer.kt") + public void testLocalClassInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("LocalClassProperty.kt") + public void testLocalClassProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassProperty.kt"); + doTest(fileName); + } + + @TestMetadata("LocalObject.kt") + public void testLocalObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalObject.kt"); + doTest(fileName); + } + + @TestMetadata("LocalObjectDelegation.kt") + public void testLocalObjectDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/LocalObjectDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("NestedLocalClass.kt") + public void testNestedLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlow/local/NestedLocalClass.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DataFlowInfoTraversal extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDataFlowInfoTraversal() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AndOr.kt") + public void testAndOr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayAccess.kt") + public void testArrayAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayExpression.kt") + public void testArrayExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayExpression.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayGetSetConvention.kt") + public void testArrayGetSetConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayGetSetConvention.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayIndices.kt") + public void testArrayIndices() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayIndices.kt"); + doTest(fileName); + } + + @TestMetadata("Assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Assignment.kt"); + doTest(fileName); + } + + @TestMetadata("AssignmentInInitializer.kt") + public void testAssignmentInInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentInInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("AssignmentOperation.kt") + public void testAssignmentOperation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentOperation.kt"); + doTest(fileName); + } + + @TestMetadata("AssignmentToArrayElement.kt") + public void testAssignmentToArrayElement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentToArrayElement.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpression.kt") + public void testBinaryExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionBooleanOperations.kt") + public void testBinaryExpressionBooleanOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionCompareToConvention.kt") + public void testBinaryExpressionCompareToConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionCompareToConvention.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionContainsConvention.kt") + public void testBinaryExpressionContainsConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionContainsConvention.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionElvis.kt") + public void testBinaryExpressionElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionEqualsConvention.kt") + public void testBinaryExpressionEqualsConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionEqualsConvention.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionIdentifier.kt") + public void testBinaryExpressionIdentifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionIdentifier.kt"); + doTest(fileName); + } + + @TestMetadata("BinaryExpressionPlusConvention.kt") + public void testBinaryExpressionPlusConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionPlusConvention.kt"); + doTest(fileName); + } + + @TestMetadata("Condition.kt") + public void testCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Condition.kt"); + doTest(fileName); + } + + @TestMetadata("ContinueOuterLoop.kt") + public void testContinueOuterLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ContinueOuterLoop.kt"); + doTest(fileName); + } + + @TestMetadata("DeepIf.kt") + public void testDeepIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt"); + doTest(fileName); + } + + @TestMetadata("DoWhile.kt") + public void testDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("DoWhileCondition.kt") + public void testDoWhileCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.kt"); + doTest(fileName); + } + + @TestMetadata("Elvis.kt") + public void testElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.kt"); + doTest(fileName); + } + + @TestMetadata("ExclExcl.kt") + public void testExclExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt"); + doTest(fileName); + } + + @TestMetadata("For.kt") + public void testFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.kt"); + doTest(fileName); + } + + @TestMetadata("ForLoopRange.kt") + public void testForLoopRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ForLoopRange.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionLiteral.kt") + public void testFunctionLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("IfStatement.kt") + public void testIfStatement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.kt"); + doTest(fileName); + } + + @TestMetadata("IfThenElse.kt") + public void testIfThenElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt"); + doTest(fileName); + } + + @TestMetadata("IfThenElseBothInvalid.kt") + public void testIfThenElseBothInvalid() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.kt"); + doTest(fileName); + } + + @TestMetadata("IsExpression.kt") + public void testIsExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IsExpression.kt"); + doTest(fileName); + } + + @TestMetadata("kt4332WhenBranches.kt") + public void testKt4332WhenBranches() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt4332WhenBranches.kt"); + doTest(fileName); + } + + @TestMetadata("kt5155WhenBranches.kt") + public void testKt5155WhenBranches() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt5155WhenBranches.kt"); + doTest(fileName); + } + + @TestMetadata("kt5182WhenBranches.kt") + public void testKt5182WhenBranches() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt5182WhenBranches.kt"); + doTest(fileName); + } + + @TestMetadata("ManyIfs.kt") + public void testManyIfs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt"); + doTest(fileName); + } + + @TestMetadata("MultiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/MultiDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("ObjectExpression.kt") + public void testObjectExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt"); + doTest(fileName); + } + + @TestMetadata("QualifiedExpression.kt") + public void testQualifiedExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.kt"); + doTest(fileName); + } + + @TestMetadata("Return.kt") + public void testReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt"); + doTest(fileName); + } + + @TestMetadata("StringTemplate.kt") + public void testStringTemplate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/StringTemplate.kt"); + doTest(fileName); + } + + @TestMetadata("ThisSuper.kt") + public void testThisSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt"); + doTest(fileName); + } + + @TestMetadata("Throw.kt") + public void testThrow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt"); + doTest(fileName); + } + + @TestMetadata("TryCatch.kt") + public void testTryCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt"); + doTest(fileName); + } + + @TestMetadata("TryFinally.kt") + public void testTryFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.kt"); + doTest(fileName); + } + + @TestMetadata("UnaryExpression.kt") + public void testUnaryExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/UnaryExpression.kt"); + doTest(fileName); + } + + @TestMetadata("When.kt") + public void testWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/When.kt"); + doTest(fileName); + } + + @TestMetadata("WhenEntryAs.kt") + public void testWhenEntryAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryAs.kt"); + doTest(fileName); + } + + @TestMetadata("WhenEntryIs.kt") + public void testWhenEntryIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.kt"); + doTest(fileName); + } + + @TestMetadata("WhenIn.kt") + public void testWhenIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenIn.kt"); + doTest(fileName); + } + + @TestMetadata("WhenSubject.kt") + public void testWhenSubject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenSubject.kt"); + doTest(fileName); + } + + @TestMetadata("While.kt") + public void testWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt"); + doTest(fileName); + } + + @TestMetadata("WhileCondition.kt") + public void testWhileCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Smartcasts extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSmartcasts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("SmartcastAmbiguitites.kt") + public void testSmartcastAmbiguitites() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastAmbiguitites.kt"); + doTest(fileName); + } + + @TestMetadata("SmartcastsForStableIdentifiers.kt") + public void testSmartcastsForStableIdentifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastsForStableIdentifiers.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DeclarationChecks extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDeclarationChecks() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguousObjectExpressionType.kt") + public void testAmbiguousObjectExpressionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt"); + doTest(fileName); + } + + @TestMetadata("anonymousFunAsLastExpressionInBlock.kt") + public void testAnonymousFunAsLastExpressionInBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/anonymousFunAsLastExpressionInBlock.kt"); + doTest(fileName); + } + + @TestMetadata("anonymousFunUnusedLastExpressionInBlock.kt") + public void testAnonymousFunUnusedLastExpressionInBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/anonymousFunUnusedLastExpressionInBlock.kt"); + doTest(fileName); + } + + @TestMetadata("ComponentFunctionReturnTypeMismatch.kt") + public void testComponentFunctionReturnTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingAndRedundantProjections.kt") + public void testConflictingAndRedundantProjections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/ConflictingAndRedundantProjections.kt"); + doTest(fileName); + } + + @TestMetadata("DataFlowInMultiDeclInFor.kt") + public void testDataFlowInMultiDeclInFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/DataFlowInMultiDeclInFor.kt"); + doTest(fileName); + } + + @TestMetadata("DataFlowInfoInMultiDecl.kt") + public void testDataFlowInfoInMultiDecl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/DataFlowInfoInMultiDecl.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionWithMissingNames.kt") + public void testFunctionWithMissingNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt"); + doTest(fileName); + } + + @TestMetadata("illegalModifiersOnClass.kt") + public void testIllegalModifiersOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("kClassInSignature.kt") + public void testKClassInSignature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kClassInSignature.kt"); + doTest(fileName); + } + + @TestMetadata("kt1141.kt") + public void testKt1141() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt"); + doTest(fileName); + } + + @TestMetadata("kt1193.kt") + public void testKt1193() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt1193.kt"); + doTest(fileName); + } + + @TestMetadata("kt2096.kt") + public void testKt2096() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt2096.kt"); + doTest(fileName); + } + + @TestMetadata("kt2142.kt") + public void testKt2142() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt2142.kt"); + doTest(fileName); + } + + @TestMetadata("kt2397.kt") + public void testKt2397() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt2397.kt"); + doTest(fileName); + } + + @TestMetadata("kt2631_MultipleDeclaration.kt") + public void testKt2631_MultipleDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("kt2643MultiDeclInControlFlow.kt") + public void testKt2643MultiDeclInControlFlow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt2643MultiDeclInControlFlow.kt"); + doTest(fileName); + } + + @TestMetadata("kt559.kt") + public void testKt559() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/kt559.kt"); + doTest(fileName); + } + + @TestMetadata("localDeclarationModifiers.kt") + public void testLocalDeclarationModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("localFunctionNoInheritVisibility.kt") + public void testLocalFunctionNoInheritVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("LocalVariableWithNoTypeInformation.kt") + public void testLocalVariableWithNoTypeInformation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt"); + doTest(fileName); + } + + @TestMetadata("mulitpleVarargParameters.kt") + public void testMulitpleVarargParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.kt"); + doTest(fileName); + } + + @TestMetadata("MultiDeclarationErrors.kt") + public void testMultiDeclarationErrors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt"); + doTest(fileName); + } + + @TestMetadata("namedFunAsLastExpressionInBlock.kt") + public void testNamedFunAsLastExpressionInBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt"); + doTest(fileName); + } + + @TestMetadata("packageDeclarationModifiers.kt") + public void testPackageDeclarationModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("propertyInPackageHasNoInheritVisibility.kt") + public void testPropertyInPackageHasNoInheritVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationsInMultiDecl.kt") + public void testRedeclarationsInMultiDecl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/RedeclarationsInMultiDecl.kt"); + doTest(fileName); + } + + @TestMetadata("ScalaLikeNamedFun.kt") + public void testScalaLikeNamedFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.kt"); + doTest(fileName); + } + + @TestMetadata("sealedOnMembers.kt") + public void testSealedOnMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.kt"); + doTest(fileName); + } + + @TestMetadata("unambiguousObjectExpressionType.kt") + public void testUnambiguousObjectExpressionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt"); + doTest(fileName); + } + + @TestMetadata("valVarFunctionParameter.kt") + public void testValVarFunctionParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/valVarFunctionParameter.kt"); + doTest(fileName); + } + + @TestMetadata("VarianceOnFunctionAndPropertyTypeParameters.kt") + public void testVarianceOnFunctionAndPropertyTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/VarianceOnFunctionAndPropertyTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DestructuringDeclarations extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDestructuringDeclarations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("destructuringDeclarationAssignedUnresolved.kt") + public void testDestructuringDeclarationAssignedUnresolved() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt"); + doTest(fileName); + } + + @TestMetadata("destructuringDeclarationMissingInitializer.kt") + public void testDestructuringDeclarationMissingInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("DoubleDeclForLoop.kt") + public void testDoubleDeclForLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/DoubleDeclForLoop.kt"); + doTest(fileName); + } + + @TestMetadata("FolLoopTypeComponentTypeMismatch.kt") + public void testFolLoopTypeComponentTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("ForLoopComponentFunctionAmbiguity.kt") + public void testForLoopComponentFunctionAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("ForLoopComponentFunctionMissing.kt") + public void testForLoopComponentFunctionMissing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.kt"); + doTest(fileName); + } + + @TestMetadata("ForLoopMissingLoopParameter.kt") + public void testForLoopMissingLoopParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ForLoopWithExtensions.kt") + public void testForLoopWithExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopWithExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("ForWithExplicitTypes.kt") + public void testForWithExplicitTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForWithExplicitTypes.kt"); + doTest(fileName); + } + + @TestMetadata("kt2829.kt") + public void testKt2829() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/kt2829.kt"); + doTest(fileName); + } + + @TestMetadata("lastDestructuringDeclarationInBlock.kt") + public void testLastDestructuringDeclarationInBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/lastDestructuringDeclarationInBlock.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationInForLoop.kt") + public void testRedeclarationInForLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/RedeclarationInForLoop.kt"); + doTest(fileName); + } + + @TestMetadata("SingleDeclForLoop.kt") + public void testSingleDeclForLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/SingleDeclForLoop.kt"); + doTest(fileName); + } + + @TestMetadata("underscore.kt") + public void testUnderscore() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FiniteBoundRestriction extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInFiniteBoundRestriction() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("CasesWithOneTypeParameter.kt") + public void testCasesWithOneTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("CasesWithTwoTypeParameters.kt") + public void testCasesWithTwoTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithTwoTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("JavaSuperType.kt") + public void testJavaSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/JavaSuperType.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonExpansiveInheritanceRestriction extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNonExpansiveInheritanceRestriction() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("JavaWithKotlin.kt") + public void testJavaWithKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("JavaWithKotlin2.kt") + public void testJavaWithKotlin2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt"); + doTest(fileName); + } + + @TestMetadata("PureKotlin.kt") + public void testPureKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/PureKotlin.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultArguments extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDefaultArguments() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt5232.kt") + public void testKt5232() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/defaultArguments/kt5232.kt"); + doTest(fileName); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/defaultArguments/superCall.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DelegatedProperty extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("absentErrorAboutInitializer.kt") + public void testAbsentErrorAboutInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/absentErrorAboutInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("absentErrorAboutType.kt") + public void testAbsentErrorAboutType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/absentErrorAboutType.kt"); + doTest(fileName); + } + + @TestMetadata("abstractDelegatedProperty.kt") + public void testAbstractDelegatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/abstractDelegatedProperty.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInDelegatedProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("backingField.kt") + public void testBackingField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/backingField.kt"); + doTest(fileName); + } + + @TestMetadata("defaultGetter.kt") + public void testDefaultGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/defaultGetter.kt"); + doTest(fileName); + } + + @TestMetadata("defaultSetter.kt") + public void testDefaultSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/defaultSetter.kt"); + doTest(fileName); + } + + @TestMetadata("delegatedPropertyOverridedInTrait.kt") + public void testDelegatedPropertyOverridedInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/delegatedPropertyOverridedInTrait.kt"); + doTest(fileName); + } + + @TestMetadata("delegatedPropertyOverridedInTraitTypeMismatch.kt") + public void testDelegatedPropertyOverridedInTraitTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/delegatedPropertyOverridedInTraitTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("disallowImplInTypeParameter.kt") + public void testDisallowImplInTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/disallowImplInTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("genericGetter.kt") + public void testGenericGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/genericGetter.kt"); + doTest(fileName); + } + + @TestMetadata("getterWithSubtype.kt") + public void testGetterWithSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/getterWithSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("inTrait.kt") + public void testInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inTrait.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteTypeInference.kt") + public void testIncompleteTypeInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.kt"); + doTest(fileName); + } + + @TestMetadata("kt4640.kt") + public void testKt4640() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/kt4640.kt"); + doTest(fileName); + } + + @TestMetadata("localVariable.kt") + public void testLocalVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/localVariable.kt"); + doTest(fileName); + } + + @TestMetadata("localWithSmartCast.kt") + public void testLocalWithSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/localWithSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("missedGetter.kt") + public void testMissedGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt"); + doTest(fileName); + } + + @TestMetadata("missedSetter.kt") + public void testMissedSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt"); + doTest(fileName); + } + + @TestMetadata("nonDefaultAccessors.kt") + public void testNonDefaultAccessors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/nonDefaultAccessors.kt"); + doTest(fileName); + } + + @TestMetadata("propertyDefferedType.kt") + public void testPropertyDefferedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveType.kt") + public void testRecursiveType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt"); + doTest(fileName); + } + + @TestMetadata("redundantGetter.kt") + public void testRedundantGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/redundantGetter.kt"); + doTest(fileName); + } + + @TestMetadata("redundantSetter.kt") + public void testRedundantSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/redundantSetter.kt"); + doTest(fileName); + } + + @TestMetadata("setterThisTypeMismatch.kt") + public void testSetterThisTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/setterThisTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("setterWithSupertype.kt") + public void testSetterWithSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/setterWithSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("severalReceivers.kt") + public void testSeveralReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/severalReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("thisInDelegate.kt") + public void testThisInDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("thisOfAnyType.kt") + public void testThisOfAnyType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/thisOfAnyType.kt"); + doTest(fileName); + } + + @TestMetadata("thisOfNothingNullableType.kt") + public void testThisOfNothingNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("thisOfNothingType.kt") + public void testThisOfNothingType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt"); + doTest(fileName); + } + + @TestMetadata("twoGetMethods.kt") + public void testTwoGetMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatchForGetReturnType.kt") + public void testTypeMismatchForGetReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatchForGetWithGeneric.kt") + public void testTypeMismatchForGetWithGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatchForSetParameter.kt") + public void testTypeMismatchForSetParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForSetParameter.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatchForThisGetParameter.kt") + public void testTypeMismatchForThisGetParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.kt"); + doTest(fileName); + } + + @TestMetadata("wrongCountOfParametersInGet.kt") + public void testWrongCountOfParametersInGet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.kt"); + doTest(fileName); + } + + @TestMetadata("wrongCountOfParametersInSet.kt") + public void testWrongCountOfParametersInSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInSet.kt"); + doTest(fileName); + } + + @TestMetadata("wrongSetterReturnType.kt") + public void testWrongSetterReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/wrongSetterReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inference extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("differentDelegatedExpressions.kt") + public void testDifferentDelegatedExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("extensionGet.kt") + public void testExtensionGet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionGet.kt"); + doTest(fileName); + } + + @TestMetadata("extensionProperty.kt") + public void testExtensionProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt"); + doTest(fileName); + } + + @TestMetadata("genericMethodInGenericClass.kt") + public void testGenericMethodInGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("genericMethods.kt") + public void testGenericMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt"); + doTest(fileName); + } + + @TestMetadata("labeledDelegatedExpression.kt") + public void testLabeledDelegatedExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/labeledDelegatedExpression.kt"); + doTest(fileName); + } + + @TestMetadata("manyIncompleteCandidates.kt") + public void testManyIncompleteCandidates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt"); + doTest(fileName); + } + + @TestMetadata("noErrorsForImplicitConstraints.kt") + public void testNoErrorsForImplicitConstraints() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt"); + doTest(fileName); + } + + @TestMetadata("noExpectedTypeForSupertypeConstraint.kt") + public void testNoExpectedTypeForSupertypeConstraint() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt"); + doTest(fileName); + } + + @TestMetadata("useCompleterWithoutExpectedType.kt") + public void testUseCompleterWithoutExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/useCompleterWithoutExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("useExpectedType.kt") + public void testUseExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("useExpectedTypeForVal.kt") + public void testUseExpectedTypeForVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedTypeForVal.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProvideDelegate extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInProvideDelegate() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("commonCaseForInference.kt") + public void testCommonCaseForInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt"); + doTest(fileName); + } + + @TestMetadata("genericProvideDelegate.kt") + public void testGenericProvideDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/genericProvideDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("hostAndReceiver1.kt") + public void testHostAndReceiver1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.kt"); + doTest(fileName); + } + + @TestMetadata("hostAndReceiver2.kt") + public void testHostAndReceiver2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt"); + doTest(fileName); + } + + @TestMetadata("hostAndReceiver3.kt") + public void testHostAndReceiver3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver3.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceFromReceiver1.kt") + public void testInferenceFromReceiver1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceFromReceiver2.kt") + public void testInferenceFromReceiver2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt"); + doTest(fileName); + } + + @TestMetadata("localDelegatedProperty.kt") + public void testLocalDelegatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/localDelegatedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("noOperatorModifierOnProvideDelegate.kt") + public void testNoOperatorModifierOnProvideDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("provideDelegateOperatorDeclaration.kt") + public void testProvideDelegateOperatorDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOperatorDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("setValue.kt") + public void testSetValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt"); + doTest(fileName); + } + + @TestMetadata("simpleProvideDelegate.kt") + public void testSimpleProvideDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/simpleProvideDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedOperatorProvideDelegate.kt") + public void testUnsupportedOperatorProvideDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Delegation extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DelegationAndOverriding.kt") + public void testDelegationAndOverriding() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt"); + doTest(fileName); + } + + @TestMetadata("DelegationExpectedType.kt") + public void testDelegationExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("DelegationNotTotrait.kt") + public void testDelegationNotTotrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt"); + doTest(fileName); + } + + @TestMetadata("DelegationToJavaIface.kt") + public void testDelegationToJavaIface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt"); + doTest(fileName); + } + + @TestMetadata("Delegation_ClashingFunctions.kt") + public void testDelegation_ClashingFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("Delegation_Hierarchy.kt") + public void testDelegation_Hierarchy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/Delegation_Hierarchy.kt"); + doTest(fileName); + } + + @TestMetadata("Delegation_MultipleDelegates.kt") + public void testDelegation_MultipleDelegates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt"); + doTest(fileName); + } + + @TestMetadata("Delegation_ScopeInitializationOrder.kt") + public void testDelegation_ScopeInitializationOrder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/Delegation_ScopeInitializationOrder.kt"); + doTest(fileName); + } + + @TestMetadata("kt8154.kt") + public void testKt8154() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/kt8154.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegation/clashes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Clashes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInClashes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("finalMemberOverridden.kt") + public void testFinalMemberOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("propertyTypeMismatch.kt") + public void testPropertyTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/clashes/propertyTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeMismatch.kt") + public void testReturnTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/clashes/returnTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("varOverriddenByVal.kt") + public void testVarOverriddenByVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/clashes/varOverriddenByVal.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CovariantOverrides extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCovariantOverrides() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("fromClass.kt") + public void testFromClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevant.kt") + public void testIrrelevant() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides/irrelevant.kt"); + doTest(fileName); + } + + @TestMetadata("kt13952.kt") + public void testKt13952() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides/kt13952.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides/simple.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MemberHidesSupertypeOverride extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("abstractOverride.kt") + public void testAbstractOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/abstractOverride.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInMemberHidesSupertypeOverride() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegationToSubType.kt") + public void testDelegationToSubType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubType.kt"); + doTest(fileName); + } + + @TestMetadata("delegationToSubTypeProperty.kt") + public void testDelegationToSubTypeProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeProperty.kt"); + doTest(fileName); + } + + @TestMetadata("delegationToSubTypeWithOverride.kt") + public void testDelegationToSubTypeWithOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeWithOverride.kt"); + doTest(fileName); + } + + @TestMetadata("delegationToSubTypeWithOverrideProperty.kt") + public void testDelegationToSubTypeWithOverrideProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeWithOverrideProperty.kt"); + doTest(fileName); + } + + @TestMetadata("diamond.kt") + public void testDiamond() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt"); + doTest(fileName); + } + + @TestMetadata("explicitOverride.kt") + public void testExplicitOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/explicitOverride.kt"); + doTest(fileName); + } + + @TestMetadata("fakeOverrideInTheMiddle.kt") + public void testFakeOverrideInTheMiddle() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/fakeOverrideInTheMiddle.kt"); + doTest(fileName); + } + + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/generic.kt"); + doTest(fileName); + } + + @TestMetadata("sameDelegationInHierarchy.kt") + public void testSameDelegationInHierarchy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy.kt"); + doTest(fileName); + } + + @TestMetadata("sameDelegationInHierarchy2.kt") + public void testSameDelegationInHierarchy2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt"); + doTest(fileName); + } + + @TestMetadata("severalDelegates.kt") + public void testSeveralDelegates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simple.kt"); + doTest(fileName); + } + + @TestMetadata("simpleNoOverride.kt") + public void testSimpleNoOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simpleNoOverride.kt"); + doTest(fileName); + } + + @TestMetadata("simpleProp.kt") + public void testSimpleProp() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simpleProp.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/deparenthesize") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Deparenthesize extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDeparenthesize() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotatedSafeCall.kt") + public void testAnnotatedSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("checkDeparenthesizedType.kt") + public void testCheckDeparenthesizedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt"); + doTest(fileName); + } + + @TestMetadata("labeledSafeCall.kt") + public void testLabeledSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deparenthesize/labeledSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("multiParenthesizedSafeCall.kt") + public void testMultiParenthesizedSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deparenthesize/multiParenthesizedSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("parenthesizedSafeCall.kt") + public void testParenthesizedSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deparenthesize/parenthesizedSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("ParenthesizedVariable.kt") + public void testParenthesizedVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deparenthesize/ParenthesizedVariable.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/deprecated") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Deprecated extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDeprecated() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationUsage.kt") + public void testAnnotationUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/annotationUsage.kt"); + doTest(fileName); + } + + @TestMetadata("classWithCompanionObject.kt") + public void testClassWithCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/classWithCompanionObject.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectUsage.kt") + public void testCompanionObjectUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/companionObjectUsage.kt"); + doTest(fileName); + } + + @TestMetadata("componentUsage.kt") + public void testComponentUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/componentUsage.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedConstructor.kt") + public void testDeprecatedConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedError.kt") + public void testDeprecatedError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedError.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedErrorBuilder.kt") + public void testDeprecatedErrorBuilder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedErrorBuilder.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedHidden.kt") + public void testDeprecatedHidden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedHidden.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedInheritance.kt") + public void testDeprecatedInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedPropertyInheritance.kt") + public void testDeprecatedPropertyInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedPropertyInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("functionUsage.kt") + public void testFunctionUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/functionUsage.kt"); + doTest(fileName); + } + + @TestMetadata("genericConstructorUsage.kt") + public void testGenericConstructorUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/genericConstructorUsage.kt"); + doTest(fileName); + } + + @TestMetadata("hiddenPropertyAccessors.kt") + public void testHiddenPropertyAccessors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/hiddenPropertyAccessors.kt"); + doTest(fileName); + } + + @TestMetadata("importJavaSamInterface.kt") + public void testImportJavaSamInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/importJavaSamInterface.kt"); + doTest(fileName); + } + + @TestMetadata("imports.kt") + public void testImports() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/imports.kt"); + doTest(fileName); + } + + @TestMetadata("iteratorUsage.kt") + public void testIteratorUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/iteratorUsage.kt"); + doTest(fileName); + } + + @TestMetadata("javaDeprecated.kt") + public void testJavaDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/javaDeprecated.kt"); + doTest(fileName); + } + + @TestMetadata("javaDeprecatedInheritance.kt") + public void testJavaDeprecatedInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("javaDocDeprecated.kt") + public void testJavaDocDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/javaDocDeprecated.kt"); + doTest(fileName); + } + + @TestMetadata("nestedTypesUsage.kt") + public void testNestedTypesUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt"); + doTest(fileName); + } + + @TestMetadata("objectUsage.kt") + public void testObjectUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/objectUsage.kt"); + doTest(fileName); + } + + @TestMetadata("propertyUsage.kt") + public void testPropertyUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/propertyUsage.kt"); + doTest(fileName); + } + + @TestMetadata("propertyUseSiteTargetedAnnotations.kt") + public void testPropertyUseSiteTargetedAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("propertyWithInvoke.kt") + public void testPropertyWithInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/propertyWithInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("thisUsage.kt") + public void testThisUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/thisUsage.kt"); + doTest(fileName); + } + + @TestMetadata("typeUsage.kt") + public void testTypeUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/typeUsage.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasConstructor.kt") + public void testTypealiasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/typealiasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasForDeprecatedClass.kt") + public void testTypealiasForDeprecatedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/typealiasForDeprecatedClass.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasUsage.kt") + public void testTypealiasUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/typealiasUsage.kt"); + doTest(fileName); + } + + @TestMetadata("unusedImport.kt") + public void testUnusedImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/unusedImport.kt"); + doTest(fileName); + } + + @TestMetadata("warningOnConstructorErrorOnClass.kt") + public void testWarningOnConstructorErrorOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/deprecated/warningOnConstructorErrorOnClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DuplicateJvmSignature extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("caseInProperties.kt") + public void testCaseInProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/caseInProperties.kt"); + doTest(fileName); + } + + @TestMetadata("missingNames.kt") + public void testMissingNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt"); + doTest(fileName); + } + + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/vararg.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AccidentalOverrides extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accidentalOverrideFromGrandparent.kt") + public void testAccidentalOverrideFromGrandparent() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInAccidentalOverrides() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classFunctionOverriddenByProperty.kt") + public void testClassFunctionOverriddenByProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); + doTest(fileName); + } + + @TestMetadata("classFunctionOverriddenByPropertyInConstructor.kt") + public void testClassFunctionOverriddenByPropertyInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("classFunctionOverriddenByPropertyNoGetter.kt") + public void testClassFunctionOverriddenByPropertyNoGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt"); + doTest(fileName); + } + + @TestMetadata("classPropertyOverriddenByFunction.kt") + public void testClassPropertyOverriddenByFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); + doTest(fileName); + } + + @TestMetadata("defaultFunction.kt") + public void testDefaultFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/defaultFunction.kt"); + doTest(fileName); + } + + @TestMetadata("delegatedFunctionOverriddenByProperty.kt") + public void testDelegatedFunctionOverriddenByProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt"); + doTest(fileName); + } + + @TestMetadata("genericClassFunction.kt") + public void testGenericClassFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt"); + doTest(fileName); + } + + @TestMetadata("overridesNothing.kt") + public void testOverridesNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/overridesNothing.kt"); + doTest(fileName); + } + + @TestMetadata("privateClassFunctionOverriddenByProperty.kt") + public void testPrivateClassFunctionOverriddenByProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt"); + doTest(fileName); + } + + @TestMetadata("require.kt") + public void testRequire() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/require.kt"); + doTest(fileName); + } + + @TestMetadata("traitFunctionOverriddenByProperty.kt") + public void testTraitFunctionOverriddenByProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt"); + doTest(fileName); + } + + @TestMetadata("traitFunctionOverriddenByPropertyNoImpl.kt") + public void testTraitFunctionOverriddenByPropertyNoImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt"); + doTest(fileName); + } + + @TestMetadata("traitPropertyOverriddenByFunction.kt") + public void testTraitPropertyOverriddenByFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt"); + doTest(fileName); + } + + @TestMetadata("traitPropertyOverriddenByFunctionNoImpl.kt") + public void testTraitPropertyOverriddenByFunctionNoImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Bridges extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInBridges() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/class.kt"); + doTest(fileName); + } + + @TestMetadata("fakeOverrideTrait.kt") + public void testFakeOverrideTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/fakeOverrideTrait.kt"); + doTest(fileName); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/trait.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Erasure extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInErasure() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("clashFromInterfaceAndSuperClass.kt") + public void testClashFromInterfaceAndSuperClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass.kt"); + doTest(fileName); + } + + @TestMetadata("collections.kt") + public void testCollections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt"); + doTest(fileName); + } + + @TestMetadata("delegateToTwoTraits.kt") + public void testDelegateToTwoTraits() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt"); + doTest(fileName); + } + + @TestMetadata("delegationAndOwnMethod.kt") + public void testDelegationAndOwnMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt"); + doTest(fileName); + } + + @TestMetadata("delegationToTraitImplAndOwnMethod.kt") + public void testDelegationToTraitImplAndOwnMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod.kt"); + doTest(fileName); + } + + @TestMetadata("extensionProperties.kt") + public void testExtensionProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/extensionProperties.kt"); + doTest(fileName); + } + + @TestMetadata("genericType.kt") + public void testGenericType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt"); + doTest(fileName); + } + + @TestMetadata("inheritFromTwoTraits.kt") + public void testInheritFromTwoTraits() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinAndJavaCollections.kt") + public void testKotlinAndJavaCollections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt"); + doTest(fileName); + } + + @TestMetadata("nullableType.kt") + public void testNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt"); + doTest(fileName); + } + + @TestMetadata("superTraitAndDelegationToTraitImpl.kt") + public void testSuperTraitAndDelegationToTraitImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl.kt"); + doTest(fileName); + } + + @TestMetadata("twoTraitsAndOwnFunction.kt") + public void testTwoTraitsAndOwnFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction.kt"); + doTest(fileName); + } + + @TestMetadata("typeMappedToJava.kt") + public void testTypeMappedToJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterWithBound.kt") + public void testTypeParameterWithBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterWithTwoBounds.kt") + public void testTypeParameterWithTwoBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterWithTwoBoundsInWhere.kt") + public void testTypeParameterWithTwoBoundsInWhere() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FinalMembersFromBuiltIns extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("enumMembers.kt") + public void testEnumMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns/enumMembers.kt"); + doTest(fileName); + } + + @TestMetadata("waitNotifyGetClass.kt") + public void testWaitNotifyGetClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns/waitNotifyGetClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionAndProperty extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInFunctionAndProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("class.kt") + public void testClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt"); + doTest(fileName); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt"); + doTest(fileName); + } + + @TestMetadata("classPropertyInConstructor.kt") + public void testClassPropertyInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classPropertyInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFunctionAndNormalFunction.kt") + public void testExtensionFunctionAndNormalFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt"); + doTest(fileName); + } + + @TestMetadata("extensionPropertyAndFunction.kt") + public void testExtensionPropertyAndFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt"); + doTest(fileName); + } + + @TestMetadata("functionAndSetter.kt") + public void testFunctionAndSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt"); + doTest(fileName); + } + + @TestMetadata("functionAndVar.kt") + public void testFunctionAndVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt"); + doTest(fileName); + } + + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt"); + doTest(fileName); + } + + @TestMetadata("localClassInClass.kt") + public void testLocalClassInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClassInClass.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt"); + doTest(fileName); + } + + @TestMetadata("objectExpression.kt") + public void testObjectExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); + doTest(fileName); + } + + @TestMetadata("objectExpressionInConstructor.kt") + public void testObjectExpressionInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpressionInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("privateClassPropertyNoClash.kt") + public void testPrivateClassPropertyNoClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/privateClassPropertyNoClash.kt"); + doTest(fileName); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelDifferentFiles.kt") + public void testTopLevelDifferentFiles() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelGetter.kt") + public void testTopLevelGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt"); + doTest(fileName); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt"); + doTest(fileName); + } + + @TestMetadata("withErrorTypes.kt") + public void testWithErrorTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/withErrorTypes.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SpecialNames extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSpecialNames() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectCopiedField.kt") + public void testClassObjectCopiedField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedField.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectCopiedFieldObject.kt") + public void testClassObjectCopiedFieldObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt"); + doTest(fileName); + } + + @TestMetadata("dataClassCopy.kt") + public void testDataClassCopy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.kt"); + doTest(fileName); + } + + @TestMetadata("defaults.kt") + public void testDefaults() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt"); + doTest(fileName); + } + + @TestMetadata("delegationBy.kt") + public void testDelegationBy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt"); + doTest(fileName); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/enum.kt"); + doTest(fileName); + } + + @TestMetadata("innerClassField.kt") + public void testInnerClassField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt"); + doTest(fileName); + } + + @TestMetadata("instance.kt") + public void testInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt"); + doTest(fileName); + } + + @TestMetadata("propertyMetadataCache.kt") + public void testPropertyMetadataCache() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/propertyMetadataCache.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Statics extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInStatics() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("jjk.kt") + public void testJjk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jjk.kt"); + doTest(fileName); + } + + @TestMetadata("jk.kt") + public void testJk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jk.kt"); + doTest(fileName); + } + + @TestMetadata("jkjk.kt") + public void testJkjk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") + public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Synthesized extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSynthesized() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("enumValuesValueOf.kt") + public void testEnumValuesValueOf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized/enumValuesValueOf.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TraitImpl extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTraitImpl() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("oneTrait.kt") + public void testOneTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt"); + doTest(fileName); + } + + @TestMetadata("traitFunctionOverriddenByPropertyInTrait.kt") + public void testTraitFunctionOverriddenByPropertyInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/traitFunctionOverriddenByPropertyInTrait.kt"); + doTest(fileName); + } + + @TestMetadata("traitPropertyOverriddenByFunctionInTrait.kt") + public void testTraitPropertyOverriddenByFunctionInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/traitPropertyOverriddenByFunctionInTrait.kt"); + doTest(fileName); + } + + @TestMetadata("twoTraits.kt") + public void testTwoTraits() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/dynamicTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DynamicTypes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDynamicTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegationBy.kt") + public void testDelegationBy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dynamicTypes/delegationBy.kt"); + doTest(fileName); + } + + @TestMetadata("unsupported.kt") + public void testUnsupported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt"); + doTest(fileName); + } + + @TestMetadata("withInvisibleSynthesized.kt") + public void testWithInvisibleSynthesized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("AbstractEnum.kt") + public void testAbstractEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/AbstractEnum.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractInEnum.kt") + public void testAbstractInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractOverrideInEnum.kt") + public void testAbstractOverrideInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/AbstractOverrideInEnum.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInEnum() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classObjectInEnum.kt") + public void testClassObjectInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/classObjectInEnum.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectInEnumPrivate.kt") + public void testClassObjectInEnumPrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/classObjectInEnumPrivate.kt"); + doTest(fileName); + } + + @TestMetadata("commonSupertype.kt") + public void testCommonSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/commonSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorCallFromOutside.kt") + public void testConstructorCallFromOutside() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/ConstructorCallFromOutside.kt"); + doTest(fileName); + } + + @TestMetadata("constructorWithDefaultParametersOnly.kt") + public void testConstructorWithDefaultParametersOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.kt"); + doTest(fileName); + } + + @TestMetadata("dontCreatePackageTypeForEnumEntry.kt") + public void testDontCreatePackageTypeForEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/dontCreatePackageTypeForEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("emptyConstructor.kt") + public void testEmptyConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/emptyConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("entryShouldBeOfEnumType.kt") + public void testEntryShouldBeOfEnumType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/entryShouldBeOfEnumType.kt"); + doTest(fileName); + } + + @TestMetadata("enumEntryCannotHaveClassObject.kt") + public void testEnumEntryCannotHaveClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("enumEntryInAbstractEnum.kt") + public void testEnumEntryInAbstractEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumEntryInAbstractEnum.kt"); + doTest(fileName); + } + + @TestMetadata("enumImplementingTrait.kt") + public void testEnumImplementingTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumImplementingTrait.kt"); + doTest(fileName); + } + + @TestMetadata("enumInheritance.kt") + public void testEnumInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("enumIsAssignableToBuiltInEnum.kt") + public void testEnumIsAssignableToBuiltInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumIsAssignableToBuiltInEnum.kt"); + doTest(fileName); + } + + @TestMetadata("enumMissingName.kt") + public void testEnumMissingName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumMissingName.kt"); + doTest(fileName); + } + + @TestMetadata("enumModifier.kt") + public void testEnumModifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumModifier.kt"); + doTest(fileName); + } + + @TestMetadata("enumStarImport.kt") + public void testEnumStarImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumStarImport.kt"); + doTest(fileName); + } + + @TestMetadata("enumSubjectTypeCheck.kt") + public void testEnumSubjectTypeCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt"); + doTest(fileName); + } + + @TestMetadata("enumWithAnnotationKeyword.kt") + public void testEnumWithAnnotationKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("enumWithEmptyName.kt") + public void testEnumWithEmptyName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/enumWithEmptyName.kt"); + doTest(fileName); + } + + @TestMetadata("ExplicitConstructorCall.kt") + public void testExplicitConstructorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/ExplicitConstructorCall.kt"); + doTest(fileName); + } + + @TestMetadata("extendingEnumDirectly.kt") + public void testExtendingEnumDirectly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/extendingEnumDirectly.kt"); + doTest(fileName); + } + + @TestMetadata("extensionNamedAsEnumEntry.kt") + public void testExtensionNamedAsEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/extensionNamedAsEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("ifEnumEntry.kt") + public void testIfEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/ifEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("importEnumFromJava.kt") + public void testImportEnumFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/importEnumFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("inheritFromEnumEntry.kt") + public void testInheritFromEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inheritFromEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("inheritanceFromEnum.kt") + public void testInheritanceFromEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt"); + doTest(fileName); + } + + @TestMetadata("inline.kt") + public void testInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inline.kt"); + doTest(fileName); + } + + @TestMetadata("InsideEntryConstructorCall.kt") + public void testInsideEntryConstructorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/InsideEntryConstructorCall.kt"); + doTest(fileName); + } + + @TestMetadata("InsideSecondaryConstructorCall.kt") + public void testInsideSecondaryConstructorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/InsideSecondaryConstructorCall.kt"); + doTest(fileName); + } + + @TestMetadata("interfaceWithEnumKeyword.kt") + public void testInterfaceWithEnumKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("isEnumEntry.kt") + public void testIsEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/isEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("javaEnumValueOfMethod.kt") + public void testJavaEnumValueOfMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/javaEnumValueOfMethod.kt"); + doTest(fileName); + } + + @TestMetadata("javaEnumValuesMethod.kt") + public void testJavaEnumValuesMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/javaEnumValuesMethod.kt"); + doTest(fileName); + } + + @TestMetadata("javaEnumWithAbstractFun.kt") + public void testJavaEnumWithAbstractFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/javaEnumWithAbstractFun.kt"); + doTest(fileName); + } + + @TestMetadata("javaEnumWithFuns.kt") + public void testJavaEnumWithFuns() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/javaEnumWithFuns.kt"); + doTest(fileName); + } + + @TestMetadata("javaEnumWithNameClashing.kt") + public void testJavaEnumWithNameClashing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/javaEnumWithNameClashing.kt"); + doTest(fileName); + } + + @TestMetadata("javaEnumWithProperty.kt") + public void testJavaEnumWithProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/javaEnumWithProperty.kt"); + doTest(fileName); + } + + @TestMetadata("kt2834.kt") + public void testKt2834() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/kt2834.kt"); + doTest(fileName); + } + + @TestMetadata("kt8972_cloneNotAllowed.kt") + public void testKt8972_cloneNotAllowed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt"); + doTest(fileName); + } + + @TestMetadata("localEnums.kt") + public void testLocalEnums() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/localEnums.kt"); + doTest(fileName); + } + + @TestMetadata("modifiersOnEnumEntry.kt") + public void testModifiersOnEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("multipleConstructors.kt") + public void testMultipleConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/multipleConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("NonPrivateConstructor.kt") + public void testNonPrivateConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/NonPrivateConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("openMemberInEnum.kt") + public void testOpenMemberInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/openMemberInEnum.kt"); + doTest(fileName); + } + + @TestMetadata("overrideFinalEnumMethods.kt") + public void testOverrideFinalEnumMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/overrideFinalEnumMethods.kt"); + doTest(fileName); + } + + @TestMetadata("SecondaryConstructorCall.kt") + public void testSecondaryConstructorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/SecondaryConstructorCall.kt"); + doTest(fileName); + } + + @TestMetadata("starImportNestedClassAndEntries.kt") + public void testStarImportNestedClassAndEntries() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/starImportNestedClassAndEntries.kt"); + doTest(fileName); + } + + @TestMetadata("typeParametersInEnum.kt") + public void testTypeParametersInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/typeParametersInEnum.kt"); + doTest(fileName); + } + + @TestMetadata("valuesValueOfAndEntriesAccessibility.kt") + public void testValuesValueOfAndEntriesAccessibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/valuesValueOfAndEntriesAccessibility.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/enum/inner") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inner extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInner() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("existingClassObject.kt") + public void testExistingClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/existingClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("insideClass.kt") + public void testInsideClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideClass.kt"); + doTest(fileName); + } + + @TestMetadata("insideClassObject.kt") + public void testInsideClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("insideEnum.kt") + public void testInsideEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideEnum.kt"); + doTest(fileName); + } + + @TestMetadata("insideEnumEntry.kt") + public void testInsideEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry.kt"); + doTest(fileName); + } + + @TestMetadata("insideInnerClassNotAllowed.kt") + public void testInsideInnerClassNotAllowed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt"); + doTest(fileName); + } + + @TestMetadata("insideObject.kt") + public void testInsideObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideObject.kt"); + doTest(fileName); + } + + @TestMetadata("insideTrait.kt") + public void testInsideTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/insideTrait.kt"); + doTest(fileName); + } + + @TestMetadata("redeclarationInClassObject.kt") + public void testRedeclarationInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/redeclarationInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("twoEnums.kt") + public void testTwoEnums() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/twoEnums.kt"); + doTest(fileName); + } + + @TestMetadata("twoEnumsInClassObjectAndInnerClass.kt") + public void testTwoEnumsInClassObjectAndInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/evaluate") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Evaluate extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInEvaluate() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("binaryMinusDepOnExpType.kt") + public void testBinaryMinusDepOnExpType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt"); + doTest(fileName); + } + + @TestMetadata("binaryMinusIndepWoExpType.kt") + public void testBinaryMinusIndepWoExpType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.kt"); + doTest(fileName); + } + + @TestMetadata("binaryMinusIndependentExpType.kt") + public void testBinaryMinusIndependentExpType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndependentExpType.kt"); + doTest(fileName); + } + + @TestMetadata("divisionByZero.kt") + public void testDivisionByZero() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt"); + doTest(fileName); + } + + @TestMetadata("float.kt") + public void testFloat() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/float.kt"); + doTest(fileName); + } + + @TestMetadata("floatLiteralOutOfRange.kt") + public void testFloatLiteralOutOfRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/floatLiteralOutOfRange.kt"); + doTest(fileName); + } + + @TestMetadata("infixFunOverBuiltinMemberInConst.kt") + public void testInfixFunOverBuiltinMemberInConst() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/infixFunOverBuiltinMemberInConst.kt"); + doTest(fileName); + } + + @TestMetadata("intOverflow.kt") + public void testIntOverflow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/intOverflow.kt"); + doTest(fileName); + } + + @TestMetadata("intOverflowWithJavaProperties.kt") + public void testIntOverflowWithJavaProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/intOverflowWithJavaProperties.kt"); + doTest(fileName); + } + + @TestMetadata("integer.kt") + public void testInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/integer.kt"); + doTest(fileName); + } + + @TestMetadata("logicWithNumber.kt") + public void testLogicWithNumber() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt"); + doTest(fileName); + } + + @TestMetadata("longOverflow.kt") + public void testLongOverflow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/longOverflow.kt"); + doTest(fileName); + } + + @TestMetadata("noOverflowWithZero.kt") + public void testNoOverflowWithZero() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/noOverflowWithZero.kt"); + doTest(fileName); + } + + @TestMetadata("numberBinaryOperations.kt") + public void testNumberBinaryOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.kt"); + doTest(fileName); + } + + @TestMetadata("numberBinaryOperationsCall.kt") + public void testNumberBinaryOperationsCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.kt"); + doTest(fileName); + } + + @TestMetadata("numberBinaryOperationsInfixCall.kt") + public void testNumberBinaryOperationsInfixCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt"); + doTest(fileName); + } + + @TestMetadata("otherOverflow.kt") + public void testOtherOverflow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/otherOverflow.kt"); + doTest(fileName); + } + + @TestMetadata("parentesized.kt") + public void testParentesized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/parentesized.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedExpressions.kt") + public void testQualifiedExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/qualifiedExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("unaryMinusDepOnExpType.kt") + public void testUnaryMinusDepOnExpType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.kt"); + doTest(fileName); + } + + @TestMetadata("unaryMinusIndepWoExpType.kt") + public void testUnaryMinusIndepWoExpType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt"); + doTest(fileName); + } + + @TestMetadata("unaryMinusIndependentExpType.kt") + public void testUnaryMinusIndependentExpType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/unaryMinusIndependentExpType.kt"); + doTest(fileName); + } + + @TestMetadata("wrongLongSuffix.kt") + public void testWrongLongSuffix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/evaluate/wrongLongSuffix.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/exposed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Exposed extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInExposed() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/delegate.kt"); + doTest(fileName); + } + + @TestMetadata("exceptionOnFakeInvisible.kt") + public void testExceptionOnFakeInvisible() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/exceptionOnFakeInvisible.kt"); + doTest(fileName); + } + + @TestMetadata("functional.kt") + public void testFunctional() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/functional.kt"); + doTest(fileName); + } + + @TestMetadata("implements.kt") + public void testImplements() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/implements.kt"); + doTest(fileName); + } + + @TestMetadata("inaccessibleType.kt") + public void testInaccessibleType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/inaccessibleType.kt"); + doTest(fileName); + } + + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/internal.kt"); + doTest(fileName); + } + + @TestMetadata("internalAndProtected.kt") + public void testInternalAndProtected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/internalAndProtected.kt"); + doTest(fileName); + } + + @TestMetadata("internalFromLocal.kt") + public void testInternalFromLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/internalFromLocal.kt"); + doTest(fileName); + } + + @TestMetadata("local.kt") + public void testLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/local.kt"); + doTest(fileName); + } + + @TestMetadata("localFromInternal.kt") + public void testLocalFromInternal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localFromInternal.kt"); + doTest(fileName); + } + + @TestMetadata("localFromPrivate.kt") + public void testLocalFromPrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localFromPrivate.kt"); + doTest(fileName); + } + + @TestMetadata("localInFunReturnType.kt") + public void testLocalInFunReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("localInMemberType.kt") + public void testLocalInMemberType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localInMemberType.kt"); + doTest(fileName); + } + + @TestMetadata("localInPropertyType.kt") + public void testLocalInPropertyType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt"); + doTest(fileName); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/nested.kt"); + doTest(fileName); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/object.kt"); + doTest(fileName); + } + + @TestMetadata("packagePrivate.kt") + public void testPackagePrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/packagePrivate.kt"); + doTest(fileName); + } + + @TestMetadata("privateFromLocal.kt") + public void testPrivateFromLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/privateFromLocal.kt"); + doTest(fileName); + } + + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/protected.kt"); + doTest(fileName); + } + + @TestMetadata("protectedInProtected.kt") + public void testProtectedInProtected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/protectedInProtected.kt"); + doTest(fileName); + } + + @TestMetadata("protectedJava.kt") + public void testProtectedJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/protectedJava.kt"); + doTest(fileName); + } + + @TestMetadata("protectedSameWay.kt") + public void testProtectedSameWay() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/protectedSameWay.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/simple.kt"); + doTest(fileName); + } + + @TestMetadata("typeArgs.kt") + public void testTypeArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/exposed/typeArgs.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/extensions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Extensions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInExtensions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/classObject.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionFunctions.kt") + public void testExtensionFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("extensionMemberInClassObject.kt") + public void testExtensionMemberInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("extensionPropertyVsParameter.kt") + public void testExtensionPropertyVsParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/extensionPropertyVsParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionsCalledOnSuper.kt") + public void testExtensionsCalledOnSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.kt"); + doTest(fileName); + } + + @TestMetadata("GenericIterator.kt") + public void testGenericIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/GenericIterator.kt"); + doTest(fileName); + } + + @TestMetadata("GenericIterator2.kt") + public void testGenericIterator2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/GenericIterator2.kt"); + doTest(fileName); + } + + @TestMetadata("kt1875.kt") + public void testKt1875() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/kt1875.kt"); + doTest(fileName); + } + + @TestMetadata("kt2317.kt") + public void testKt2317() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/kt2317.kt"); + doTest(fileName); + } + + @TestMetadata("kt3470.kt") + public void testKt3470() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/kt3470.kt"); + doTest(fileName); + } + + @TestMetadata("kt3563.kt") + public void testKt3563() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/kt3563.kt"); + doTest(fileName); + } + + @TestMetadata("kt819ExtensionProperties.kt") + public void testKt819ExtensionProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt"); + doTest(fileName); + } + + @TestMetadata("noClassObjectsInJava.kt") + public void testNoClassObjectsInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/noClassObjectsInJava.kt"); + doTest(fileName); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/object.kt"); + doTest(fileName); + } + + @TestMetadata("throwOutCandidatesByReceiver.kt") + public void testThrowOutCandidatesByReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("throwOutCandidatesByReceiver2.kt") + public void testThrowOutCandidatesByReceiver2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver2.kt"); + doTest(fileName); + } + + @TestMetadata("variableInvoke.kt") + public void testVariableInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/extensions/variableInvoke.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/functionAsExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionAsExpression extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInFunctionAsExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AutoLabels.kt") + public void testAutoLabels() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/AutoLabels.kt"); + doTest(fileName); + } + + @TestMetadata("Common.kt") + public void testCommon() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/Common.kt"); + doTest(fileName); + } + + @TestMetadata("DifficultInferenceForParameter.kt") + public void testDifficultInferenceForParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/DifficultInferenceForParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ForbiddenNonLocalReturn.kt") + public void testForbiddenNonLocalReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/ForbiddenNonLocalReturn.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionType.kt") + public void testFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/FunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("InferenceParametersTypes.kt") + public void testInferenceParametersTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt"); + doTest(fileName); + } + + @TestMetadata("MissingParameterTypes.kt") + public void testMissingParameterTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt"); + doTest(fileName); + } + + @TestMetadata("NameDeprecation.kt") + public void testNameDeprecation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/NameDeprecation.kt"); + doTest(fileName); + } + + @TestMetadata("NoOverloadError.kt") + public void testNoOverloadError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/NoOverloadError.kt"); + doTest(fileName); + } + + @TestMetadata("Parameters.kt") + public void testParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/Parameters.kt"); + doTest(fileName); + } + + @TestMetadata("ReceiverByExpectedType.kt") + public void testReceiverByExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnAndLabels.kt") + public void testReturnAndLabels() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/ReturnAndLabels.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeCheck.kt") + public void testReturnTypeCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.kt"); + doTest(fileName); + } + + @TestMetadata("ScopeCheck.kt") + public void testScopeCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/ScopeCheck.kt"); + doTest(fileName); + } + + @TestMetadata("WithGenericParameters.kt") + public void testWithGenericParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt"); + doTest(fileName); + } + + @TestMetadata("WithOuterGeneric.kt") + public void testWithOuterGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("WithoutBody.kt") + public void testWithoutBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionLiterals extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInFunctionLiterals() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignmentOperationInLambda.kt") + public void testAssignmentOperationInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("assignmentOperationInLambdaWithExpectedType.kt") + public void testAssignmentOperationInLambdaWithExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("DeprecatedSyntax.kt") + public void testDeprecatedSyntax() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.kt"); + doTest(fileName); + } + + @TestMetadata("ExpectedParameterTypeMismatchVariance.kt") + public void testExpectedParameterTypeMismatchVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt"); + doTest(fileName); + } + + @TestMetadata("ExpectedParametersTypesMismatch.kt") + public void testExpectedParametersTypesMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("functionLIteralInBlockInIf.kt") + public void testFunctionLIteralInBlockInIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/functionLIteralInBlockInIf.kt"); + doTest(fileName); + } + + @TestMetadata("functionLiteralInIf.kt") + public void testFunctionLiteralInIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralInIf.kt"); + doTest(fileName); + } + + @TestMetadata("functionLiteralWithoutArgumentList.kt") + public void testFunctionLiteralWithoutArgumentList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralWithoutArgumentList.kt"); + doTest(fileName); + } + + @TestMetadata("higherOrderCallMissingParameters.kt") + public void testHigherOrderCallMissingParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.kt"); + doTest(fileName); + } + + @TestMetadata("kt11733.kt") + public void testKt11733() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt11733.kt"); + doTest(fileName); + } + + @TestMetadata("kt11733_1.kt") + public void testKt11733_1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt"); + doTest(fileName); + } + + @TestMetadata("kt16016.kt") + public void testKt16016() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt16016.kt"); + doTest(fileName); + } + + @TestMetadata("kt2906.kt") + public void testKt2906() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt2906.kt"); + doTest(fileName); + } + + @TestMetadata("kt3343.kt") + public void testKt3343() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt3343.kt"); + doTest(fileName); + } + + @TestMetadata("kt4529.kt") + public void testKt4529() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt4529.kt"); + doTest(fileName); + } + + @TestMetadata("kt6541_extensionForExtensionFunction.kt") + public void testKt6541_extensionForExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.kt"); + doTest(fileName); + } + + @TestMetadata("kt6869.kt") + public void testKt6869() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt6869.kt"); + doTest(fileName); + } + + @TestMetadata("kt7383_starProjectedFunction.kt") + public void testKt7383_starProjectedFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt"); + doTest(fileName); + } + + @TestMetadata("LabeledFunctionLiterals.kt") + public void testLabeledFunctionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("returnNull.kt") + public void testReturnNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/returnNull.kt"); + doTest(fileName); + } + + @TestMetadata("returnNullWithReturn.kt") + public void testReturnNullWithReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt"); + doTest(fileName); + } + + @TestMetadata("underscopeParameters.kt") + public void testUnderscopeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/underscopeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("unusedLiteral.kt") + public void testUnusedLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/unusedLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("unusedLiteralInsideUnitLiteral.kt") + public void testUnusedLiteralInsideUnitLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/unusedLiteralInsideUnitLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DestructuringInLambdas extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDestructuringInLambdas() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("complexInference.kt") + public void testComplexInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt"); + doTest(fileName); + } + + @TestMetadata("extensionComponents.kt") + public void testExtensionComponents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/extensionComponents.kt"); + doTest(fileName); + } + + @TestMetadata("inferredFunctionalType.kt") + public void testInferredFunctionalType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt"); + doTest(fileName); + } + + @TestMetadata("modifiers.kt") + public void testModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/modifiers.kt"); + doTest(fileName); + } + + @TestMetadata("noExpectedType.kt") + public void testNoExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("redeclaration.kt") + public void testRedeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("shadowing.kt") + public void testShadowing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/shadowing.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt"); + doTest(fileName); + } + + @TestMetadata("underscore.kt") + public void testUnderscore() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedFeature.kt") + public void testUnsupportedFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unsupportedFeature.kt"); + doTest(fileName); + } + + @TestMetadata("unusedParameters.kt") + public void testUnusedParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals/return") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Return extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AutoLabels.kt") + public void testAutoLabels() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabels.kt"); + doTest(fileName); + } + + @TestMetadata("AutoLabelsNonLocal.kt") + public void testAutoLabelsNonLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabelsNonLocal.kt"); + doTest(fileName); + } + + @TestMetadata("ForbiddenNonLocalReturnNoType.kt") + public void testForbiddenNonLocalReturnNoType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt"); + doTest(fileName); + } + + @TestMetadata("IfInReturnedExpression.kt") + public void testIfInReturnedExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/IfInReturnedExpression.kt"); + doTest(fileName); + } + + @TestMetadata("IfWithoutElse.kt") + public void testIfWithoutElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt"); + doTest(fileName); + } + + @TestMetadata("IfWithoutElseWithExplicitType.kt") + public void testIfWithoutElseWithExplicitType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt"); + doTest(fileName); + } + + @TestMetadata("LambdaWithParameter.kt") + public void testLambdaWithParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LambdaWithParameter.kt"); + doTest(fileName); + } + + @TestMetadata("LocalAndNonLocalReturnInLambda.kt") + public void testLocalAndNonLocalReturnInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalAndNonLocalReturnInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnExplicitLabelNoParens.kt") + public void testLocalReturnExplicitLabelNoParens() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelNoParens.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnExplicitLabelParens.kt") + public void testLocalReturnExplicitLabelParens() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelParens.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnHasTypeNothing.kt") + public void testLocalReturnHasTypeNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnHasTypeNothing.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnInNestedFunction.kt") + public void testLocalReturnInNestedFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedFunction.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnInNestedLambda.kt") + public void testLocalReturnInNestedLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedLambda.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnNoCoercionToUnit.kt") + public void testLocalReturnNoCoercionToUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNoCoercionToUnit.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnNull.kt") + public void testLocalReturnNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNull.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnSecondUnit.kt") + public void testLocalReturnSecondUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnSecondUnit.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnUnit.kt") + public void testLocalReturnUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnit.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnUnitAndDontCareType.kt") + public void testLocalReturnUnitAndDontCareType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnitAndDontCareType.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnUnitWithBodyExpression.kt") + public void testLocalReturnUnitWithBodyExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnitWithBodyExpression.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnWithExpectedType.kt") + public void testLocalReturnWithExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnWithExplicitUnit.kt") + public void testLocalReturnWithExplicitUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExplicitUnit.kt"); + doTest(fileName); + } + + @TestMetadata("LocalReturnsWithExplicitReturnType.kt") + public void testLocalReturnsWithExplicitReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("MixedReturnsFromLambda.kt") + public void testMixedReturnsFromLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/MixedReturnsFromLambda.kt"); + doTest(fileName); + } + + @TestMetadata("NoCommonSystem.kt") + public void testNoCommonSystem() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt"); + doTest(fileName); + } + + @TestMetadata("SmartCast.kt") + public void testSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("SmartCastWithExplicitType.kt") + public void testSmartCastWithExplicitType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/SmartCastWithExplicitType.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedReferenceInReturnBlock.kt") + public void testUnresolvedReferenceInReturnBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Generics extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInGenerics() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("argumentsForT.kt") + public void testArgumentsForT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/argumentsForT.kt"); + doTest(fileName); + } + + @TestMetadata("commonSupertypeContravariant.kt") + public void testCommonSupertypeContravariant() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt"); + doTest(fileName); + } + + @TestMetadata("commonSupertypeContravariant2.kt") + public void testCommonSupertypeContravariant2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant2.kt"); + doTest(fileName); + } + + @TestMetadata("doNotCaptureSupertype.kt") + public void testDoNotCaptureSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/doNotCaptureSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("genericsInType.kt") + public void testGenericsInType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/genericsInType.kt"); + doTest(fileName); + } + + @TestMetadata("InconsistentTypeParameterBounds.kt") + public void testInconsistentTypeParameterBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/InconsistentTypeParameterBounds.kt"); + doTest(fileName); + } + + @TestMetadata("invalidArgumentsNumberInWhere.kt") + public void testInvalidArgumentsNumberInWhere() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt"); + doTest(fileName); + } + + @TestMetadata("kt1575-Class.kt") + public void testKt1575_Class() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/kt1575-Class.kt"); + doTest(fileName); + } + + @TestMetadata("kt1575-Function.kt") + public void testKt1575_Function() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/kt1575-Function.kt"); + doTest(fileName); + } + + @TestMetadata("kt5508.kt") + public void testKt5508() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/kt5508.kt"); + doTest(fileName); + } + + @TestMetadata("kt9985.kt") + public void testKt9985() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/kt9985.kt"); + doTest(fileName); + } + + @TestMetadata("Projections.kt") + public void testProjections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/Projections.kt"); + doTest(fileName); + } + + @TestMetadata("PseudoRawTypes.kt") + public void testPseudoRawTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt"); + doTest(fileName); + } + + @TestMetadata("RawTypeInIsExpression.kt") + public void testRawTypeInIsExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.kt"); + doTest(fileName); + } + + @TestMetadata("RawTypeInIsPattern.kt") + public void testRawTypeInIsPattern() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt"); + doTest(fileName); + } + + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/recursive.kt"); + doTest(fileName); + } + + @TestMetadata("RecursiveUpperBoundCheck.kt") + public void testRecursiveUpperBoundCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundCheck.kt"); + doTest(fileName); + } + + @TestMetadata("RecursiveUpperBoundWithTwoArguments.kt") + public void testRecursiveUpperBoundWithTwoArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundWithTwoArguments.kt"); + doTest(fileName); + } + + @TestMetadata("resolveGenericBoundsBeforeSupertypes.kt") + public void testResolveGenericBoundsBeforeSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/resolveGenericBoundsBeforeSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("sameTypeParameterUse.kt") + public void testSameTypeParameterUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/sameTypeParameterUse.kt"); + doTest(fileName); + } + + @TestMetadata("suppressVarianceConflict.kt") + public void testSuppressVarianceConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParameterBounds.kt") + public void testTypeParameterBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/TypeParameterBounds.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParametersInTypeParameterBounds.kt") + public void testTypeParametersInTypeParameterBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/TypeParametersInTypeParameterBounds.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedClassifierInWhere.kt") + public void testUnresolvedClassifierInWhere() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/unresolvedClassifierInWhere.kt"); + doTest(fileName); + } + + @TestMetadata("wildcardInValueParameter.kt") + public void testWildcardInValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("wrongNumberOfTypeArgumentsDiagnostic.kt") + public void testWrongNumberOfTypeArgumentsDiagnostic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CapturedParameters extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCapturedParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("innerLocalClass.kt") + public void testInnerLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt"); + doTest(fileName); + } + + @TestMetadata("localWithTypeParameter.kt") + public void testLocalWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters/localWithTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("objectLiteral.kt") + public void testObjectLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("uncheckedCast.kt") + public void testUncheckedCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters/uncheckedCast.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/cyclicBounds") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CyclicBounds extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCyclicBounds() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/cyclicBounds/functions.kt"); + doTest(fileName); + } + + @TestMetadata("inClass.kt") + public void testInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/cyclicBounds/inClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/innerClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InnerClasses extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInnerClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("bareTypes.kt") + public void testBareTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt"); + doTest(fileName); + } + + @TestMetadata("bareTypesComplex.kt") + public void testBareTypesComplex() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/bareTypesComplex.kt"); + doTest(fileName); + } + + @TestMetadata("checkBoundsOuter.kt") + public void testCheckBoundsOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/checkBoundsOuter.kt"); + doTest(fileName); + } + + @TestMetadata("importedInner.kt") + public void testImportedInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/importedInner.kt"); + doTest(fileName); + } + + @TestMetadata("innerSuperCall.kt") + public void testInnerSuperCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCall.kt"); + doTest(fileName); + } + + @TestMetadata("innerSuperCallSecondary.kt") + public void testInnerSuperCallSecondary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCallSecondary.kt"); + doTest(fileName); + } + + @TestMetadata("innerTP.kt") + public void testInnerTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt"); + doTest(fileName); + } + + @TestMetadata("innerUncheckedCast.kt") + public void testInnerUncheckedCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt"); + doTest(fileName); + } + + @TestMetadata("innerVariance.kt") + public void testInnerVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/innerVariance.kt"); + doTest(fileName); + } + + @TestMetadata("iterator.kt") + public void testIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt"); + doTest(fileName); + } + + @TestMetadata("j+k.kt") + public void testJ_k() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/j+k.kt"); + doTest(fileName); + } + + @TestMetadata("j+k_complex.kt") + public void testJ_k_complex() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/j+k_complex.kt"); + doTest(fileName); + } + + @TestMetadata("kt3357.kt") + public void testKt3357() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt"); + doTest(fileName); + } + + @TestMetadata("kt408.kt") + public void testKt408() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/kt408.kt"); + doTest(fileName); + } + + @TestMetadata("kt6325.kt") + public void testKt6325() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/kt6325.kt"); + doTest(fileName); + } + + @TestMetadata("outerArgumentsRequired.kt") + public void testOuterArgumentsRequired() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/outerArgumentsRequired.kt"); + doTest(fileName); + } + + @TestMetadata("parameterShadowing.kt") + public void testParameterShadowing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/parameterShadowing.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedOuter.kt") + public void testQualifiedOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedTypesResolution.kt") + public void testQualifiedTypesResolution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/simple.kt"); + doTest(fileName); + } + + @TestMetadata("simpleIn.kt") + public void testSimpleIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.kt"); + doTest(fileName); + } + + @TestMetadata("simpleOut.kt") + public void testSimpleOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/simpleOut.kt"); + doTest(fileName); + } + + @TestMetadata("simpleOutUseSite.kt") + public void testSimpleOutUseSite() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt"); + doTest(fileName); + } + + @TestMetadata("substitutedMemberScope.kt") + public void testSubstitutedMemberScope() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ImplicitArguments extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInImplicitArguments() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("fromCompanionObject.kt") + public void testFromCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject.kt"); + doTest(fileName); + } + + @TestMetadata("fromOuterClassInObjectLiteral.kt") + public void testFromOuterClassInObjectLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromOuterClassInObjectLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("fromSuperClasses.kt") + public void testFromSuperClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.kt"); + doTest(fileName); + } + + @TestMetadata("fromSuperClassesLocal.kt") + public void testFromSuperClassesLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt"); + doTest(fileName); + } + + @TestMetadata("fromSuperClassesLocalInsideInner.kt") + public void testFromSuperClassesLocalInsideInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt"); + doTest(fileName); + } + + @TestMetadata("fromSuperClassesTransitive.kt") + public void testFromSuperClassesTransitive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.kt"); + doTest(fileName); + } + + @TestMetadata("inStaticScope.kt") + public void testInStaticScope() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/inStaticScope.kt"); + doTest(fileName); + } + + @TestMetadata("secondLevelDepth.kt") + public void testSecondLevelDepth() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/secondLevelDepth.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultipleBoundsMemberScope extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInMultipleBoundsMemberScope() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("conflictingReturnType.kt") + public void testConflictingReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/conflictingReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleTypes.kt") + public void testFlexibleTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/flexibleTypes.kt"); + doTest(fileName); + } + + @TestMetadata("mostSpecific.kt") + public void testMostSpecific() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/mostSpecific.kt"); + doTest(fileName); + } + + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/properties.kt"); + doTest(fileName); + } + + @TestMetadata("propertiesConflict.kt") + public void testPropertiesConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/propertiesConflict.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/simple.kt"); + doTest(fileName); + } + + @TestMetadata("validTypeParameters.kt") + public void testValidTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/validTypeParameters.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/nullability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Nullability extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNullability() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("declarationsBoundsViolation.kt") + public void testDeclarationsBoundsViolation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/declarationsBoundsViolation.kt"); + doTest(fileName); + } + + @TestMetadata("expressionsBoundsViolation.kt") + public void testExpressionsBoundsViolation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt"); + doTest(fileName); + } + + @TestMetadata("functionalBound.kt") + public void testFunctionalBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt"); + doTest(fileName); + } + + @TestMetadata("nullToGeneric.kt") + public void testNullToGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastRefinedClass.kt") + public void testSmartCastRefinedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/smartCastRefinedClass.kt"); + doTest(fileName); + } + + @TestMetadata("smartCasts.kt") + public void testSmartCasts() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastsOnThis.kt") + public void testSmartCastsOnThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastsValueArgument.kt") + public void testSmartCastsValueArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt"); + doTest(fileName); + } + + @TestMetadata("tpBoundsViolation.kt") + public void testTpBoundsViolation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt"); + doTest(fileName); + } + + @TestMetadata("tpBoundsViolationVariance.kt") + public void testTpBoundsViolationVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt"); + doTest(fileName); + } + + @TestMetadata("tpInBounds.kt") + public void testTpInBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt"); + doTest(fileName); + } + + @TestMetadata("useAsReceiver.kt") + public void testUseAsReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("useAsValueArgument.kt") + public void testUseAsValueArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProjectionsScope extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("addAll.kt") + public void testAddAll() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInProjectionsScope() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("approximateDispatchReceiver.kt") + public void testApproximateDispatchReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/approximateDispatchReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("extensionReceiverTypeMismatch.kt") + public void testExtensionReceiverTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("extensionResultSubstitution.kt") + public void testExtensionResultSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/extensionResultSubstitution.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleProjectedScope.kt") + public void testFlexibleProjectedScope() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/flexibleProjectedScope.kt"); + doTest(fileName); + } + + @TestMetadata("inValueParameter.kt") + public void testInValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("iterateOnExtension.kt") + public void testIterateOnExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/iterateOnExtension.kt"); + doTest(fileName); + } + + @TestMetadata("kt7296.kt") + public void testKt7296() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt"); + doTest(fileName); + } + + @TestMetadata("kt8647.kt") + public void testKt8647() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/kt8647.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgument.kt") + public void testLambdaArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/lambdaArgument.kt"); + doTest(fileName); + } + + @TestMetadata("leakedApproximatedType.kt") + public void testLeakedApproximatedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.kt"); + doTest(fileName); + } + + @TestMetadata("MLOut.kt") + public void testMLOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/MLOut.kt"); + doTest(fileName); + } + + @TestMetadata("multipleArgumentProjectedOut.kt") + public void testMultipleArgumentProjectedOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt"); + doTest(fileName); + } + + @TestMetadata("platformSuperClass.kt") + public void testPlatformSuperClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/platformSuperClass.kt"); + doTest(fileName); + } + + @TestMetadata("projectedOutConventions.kt") + public void testProjectedOutConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt"); + doTest(fileName); + } + + @TestMetadata("projectedOutSmartCast.kt") + public void testProjectedOutSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveUpperBoundStar.kt") + public void testRecursiveUpperBoundStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveUpperBoundStarOut.kt") + public void testRecursiveUpperBoundStarOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStarOut.kt"); + doTest(fileName); + } + + @TestMetadata("starNullability.kt") + public void testStarNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.kt"); + doTest(fileName); + } + + @TestMetadata("starNullabilityRecursive.kt") + public void testStarNullabilityRecursive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.kt"); + doTest(fileName); + } + + @TestMetadata("superClass.kt") + public void testSuperClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/superClass.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatchConventions.kt") + public void testTypeMismatchConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt"); + doTest(fileName); + } + + @TestMetadata("typeMismatchInLambda.kt") + public void testTypeMismatchInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterBounds.kt") + public void testTypeParameterBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt"); + doTest(fileName); + } + + @TestMetadata("unsafeVarianceStar.kt") + public void testUnsafeVarianceStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceStar.kt"); + doTest(fileName); + } + + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/starProjections") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class StarProjections extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInStarProjections() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("checkBounds.kt") + public void testCheckBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/starProjections/checkBounds.kt"); + doTest(fileName); + } + + @TestMetadata("collectionInheritedFromJava.kt") + public void testCollectionInheritedFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/starProjections/collectionInheritedFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("inheritedFromJava.kt") + public void testInheritedFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/starProjections/inheritedFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("inheritedFromKotlin.kt") + public void testInheritedFromKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/starProjections/inheritedFromKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("invalid.kt") + public void testInvalid() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TpAsReified extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTpAsReified() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("CapturedAsReified.kt") + public void testCapturedAsReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/CapturedAsReified.kt"); + doTest(fileName); + } + + @TestMetadata("ClassDereference.kt") + public void testClassDereference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/ClassDereference.kt"); + doTest(fileName); + } + + @TestMetadata("Conventions.kt") + public void testConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.kt"); + doTest(fileName); + } + + @TestMetadata("GenericAsReifiedArgument.kt") + public void testGenericAsReifiedArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericAsReifiedArgument.kt"); + doTest(fileName); + } + + @TestMetadata("InConstructor.kt") + public void testInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("InFunction.kt") + public void testInFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt"); + doTest(fileName); + } + + @TestMetadata("InProperty.kt") + public void testInProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/InProperty.kt"); + doTest(fileName); + } + + @TestMetadata("InType.kt") + public void testInType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/InType.kt"); + doTest(fileName); + } + + @TestMetadata("InlineableReified.kt") + public void testInlineableReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.kt"); + doTest(fileName); + } + + @TestMetadata("LocalFun.kt") + public void testLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.kt"); + doTest(fileName); + } + + @TestMetadata("NotInlineableReified.kt") + public void testNotInlineableReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/NotInlineableReified.kt"); + doTest(fileName); + } + + @TestMetadata("ReifiedClass.kt") + public void testReifiedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified/ReifiedClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/generics/varProjection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class VarProjection extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInVarProjection() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("setterNotProjectedOutAssign.kt") + public void testSetterNotProjectedOutAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt"); + doTest(fileName); + } + + @TestMetadata("setterProjectedOutAssign.kt") + public void testSetterProjectedOutAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt"); + doTest(fileName); + } + + @TestMetadata("setterProjectedOutNoPlusAssign.kt") + public void testSetterProjectedOutNoPlusAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt"); + doTest(fileName); + } + + @TestMetadata("setterProjectedOutPlusAssignDefined.kt") + public void testSetterProjectedOutPlusAssignDefined() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutPlusAssignDefined.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/imports") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Imports extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInImports() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); + doTest(fileName); + } + + @TestMetadata("AllUnderImportsSamePriorityForFunction.kt") + public void testAllUnderImportsSamePriorityForFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForFunction.kt"); + doTest(fileName); + } + + @TestMetadata("AllUnderImportsSamePriorityForProperty.kt") + public void testAllUnderImportsSamePriorityForProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForProperty.kt"); + doTest(fileName); + } + + @TestMetadata("CheckJavaVisibility.kt") + public void testCheckJavaVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/CheckJavaVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("CheckVisibility.kt") + public void testCheckVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/CheckVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("ClassClash.kt") + public void testClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ClassClash.kt"); + doTest(fileName); + } + + @TestMetadata("ClassClashStarImport.kt") + public void testClassClashStarImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt"); + doTest(fileName); + } + + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ClassImportsConflicting.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); + doTest(fileName); + } + + @TestMetadata("DefaultImportsPriority.kt") + public void testDefaultImportsPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/DefaultImportsPriority.kt"); + doTest(fileName); + } + + @TestMetadata("ExplicitImportsAmbiguity.kt") + public void testExplicitImportsAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ExplicitImportsAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("ExplicitImportsUnambiguityForFunction.kt") + public void testExplicitImportsUnambiguityForFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ExplicitImportsUnambiguityForFunction.kt"); + doTest(fileName); + } + + @TestMetadata("ExplicitPackageImportsAmbiguity.kt") + public void testExplicitPackageImportsAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ExplicitPackageImportsAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("ImportClassClash.kt") + public void testImportClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportClassClash.kt"); + doTest(fileName); + } + + @TestMetadata("ImportFromCompanionObject.kt") + public void testImportFromCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.kt"); + doTest(fileName); + } + + @TestMetadata("ImportFromCurrentWithDifferentName.kt") + public void testImportFromCurrentWithDifferentName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportFromCurrentWithDifferentName.kt"); + doTest(fileName); + } + + @TestMetadata("ImportFromObject.kt") + public void testImportFromObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportFromObject.kt"); + doTest(fileName); + } + + @TestMetadata("ImportFromRootPackage.kt") + public void testImportFromRootPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt"); + doTest(fileName); + } + + @TestMetadata("importFunctionWithAllUnderImport.kt") + public void testImportFunctionWithAllUnderImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImport.kt"); + doTest(fileName); + } + + @TestMetadata("importFunctionWithAllUnderImportAfterNamedImport.kt") + public void testImportFunctionWithAllUnderImportAfterNamedImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImportAfterNamedImport.kt"); + doTest(fileName); + } + + @TestMetadata("ImportHidingDefinitionInTheSameFile.kt") + public void testImportHidingDefinitionInTheSameFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportHidingDefinitionInTheSameFile.kt"); + doTest(fileName); + } + + @TestMetadata("ImportNestedWithDifferentName.kt") + public void testImportNestedWithDifferentName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportNestedWithDifferentName.kt"); + doTest(fileName); + } + + @TestMetadata("ImportObjectAndUseAsSupertype.kt") + public void testImportObjectAndUseAsSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportObjectAndUseAsSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("ImportObjectHidesCurrentPackage.kt") + public void testImportObjectHidesCurrentPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportObjectHidesCurrentPackage.kt"); + doTest(fileName); + } + + @TestMetadata("ImportOverloadFunctions.kt") + public void testImportOverloadFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("ImportPrivateMember.kt") + public void testImportPrivateMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt"); + doTest(fileName); + } + + @TestMetadata("ImportPrivateMemberFromOtherFile.kt") + public void testImportPrivateMemberFromOtherFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportPrivateMemberFromOtherFile.kt"); + doTest(fileName); + } + + @TestMetadata("ImportPrivateMembersWithStar.kt") + public void testImportPrivateMembersWithStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportPrivateMembersWithStar.kt"); + doTest(fileName); + } + + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportProtectedClass.kt"); + doTest(fileName); + } + + @TestMetadata("ImportResolutionOrder.kt") + public void testImportResolutionOrder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt"); + doTest(fileName); + } + + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportTwoTimes.kt"); + doTest(fileName); + } + + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportTwoTimesStar.kt"); + doTest(fileName); + } + + @TestMetadata("Imports.kt") + public void testImports() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/Imports.kt"); + doTest(fileName); + } + + @TestMetadata("ImportsConflicting.kt") + public void testImportsConflicting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/ImportsConflicting.kt"); + doTest(fileName); + } + + @TestMetadata("InaccessiblePrivateClass.kt") + public void testInaccessiblePrivateClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.kt"); + doTest(fileName); + } + + @TestMetadata("JavaPackageLocalClassNotImported.kt") + public void testJavaPackageLocalClassNotImported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/JavaPackageLocalClassNotImported.kt"); + doTest(fileName); + } + + @TestMetadata("kt13112.kt") + public void testKt13112() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/kt13112.kt"); + doTest(fileName); + } + + @TestMetadata("MalformedImports.kt") + public void testMalformedImports() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/MalformedImports.kt"); + doTest(fileName); + } + + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/NestedClassClash.kt"); + doTest(fileName); + } + + @TestMetadata("OperatorRenameOnImport.kt") + public void testOperatorRenameOnImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/OperatorRenameOnImport.kt"); + doTest(fileName); + } + + @TestMetadata("PackageLocalClassNotImported.kt") + public void testPackageLocalClassNotImported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/PackageLocalClassNotImported.kt"); + doTest(fileName); + } + + @TestMetadata("PackageLocalClassReferencedError.kt") + public void testPackageLocalClassReferencedError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/PackageVsClass.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateClassNotImported.kt") + public void testPrivateClassNotImported() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/PrivateClassNotImported.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateClassReferencedError.kt") + public void testPrivateClassReferencedError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt"); + doTest(fileName); + } + + @TestMetadata("propertyClassFileDependencyRecursion.kt") + public void testPropertyClassFileDependencyRecursion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/propertyClassFileDependencyRecursion.kt"); + doTest(fileName); + } + + @TestMetadata("RenameOnImport.kt") + public void testRenameOnImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/RenameOnImport.kt"); + doTest(fileName); + } + + @TestMetadata("StarImportFromObject.kt") + public void testStarImportFromObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/StarImportFromObject.kt"); + doTest(fileName); + } + + @TestMetadata("SyntaxError.kt") + public void testSyntaxError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/SyntaxError.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); + doTest(fileName); + } + + @TestMetadata("WrongImport.kt") + public void testWrongImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/imports/WrongImport.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/incompleteCode") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IncompleteCode extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInIncompleteCode() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayBracketsRange.kt") + public void testArrayBracketsRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/arrayBracketsRange.kt"); + doTest(fileName); + } + + @TestMetadata("checkNothingIsSubtype.kt") + public void testCheckNothingIsSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("controlStructuresErrors.kt") + public void testControlStructuresErrors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt"); + doTest(fileName); + } + + @TestMetadata("illegalSelectorCallableReference.kt") + public void testIllegalSelectorCallableReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/illegalSelectorCallableReference.kt"); + doTest(fileName); + } + + @TestMetadata("inExpr.kt") + public void testInExpr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/inExpr.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteAssignment.kt") + public void testIncompleteAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/incompleteAssignment.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteEquals.kt") + public void testIncompleteEquals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt"); + doTest(fileName); + } + + @TestMetadata("kt1955.kt") + public void testKt1955() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/kt1955.kt"); + doTest(fileName); + } + + @TestMetadata("kt2014.kt") + public void testKt2014() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt"); + doTest(fileName); + } + + @TestMetadata("kt4866UnresolvedArrayAccess.kt") + public void testKt4866UnresolvedArrayAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/kt4866UnresolvedArrayAccess.kt"); + doTest(fileName); + } + + @TestMetadata("NoSenselessComparisonForErrorType.kt") + public void testNoSenselessComparisonForErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("plusOnTheRight.kt") + public void testPlusOnTheRight() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.kt"); + doTest(fileName); + } + + @TestMetadata("pseudocodeTraverseNextInstructions.kt") + public void testPseudocodeTraverseNextInstructions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt"); + doTest(fileName); + } + + @TestMetadata("senselessComparisonWithNull.kt") + public void testSenselessComparisonWithNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/senselessComparisonWithNull.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeOfErrorType.kt") + public void testSupertypeOfErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterOnLhsOfDot.kt") + public void testTypeParameterOnLhsOfDot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/typeParameterOnLhsOfDot.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedArguments.kt") + public void testUnresolvedArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/unresolvedArguments.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedOperation.kt") + public void testUnresolvedOperation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/unresolvedOperation.kt"); + doTest(fileName); + } + + @TestMetadata("variableDeclarationInSelector.kt") + public void testVariableDeclarationInSelector() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/variableDeclarationInSelector.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DiagnosticWithSyntaxError extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDiagnosticWithSyntaxError() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayExpression.kt") + public void testArrayExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt"); + doTest(fileName); + } + + @TestMetadata("checkBackingFieldException.kt") + public void testCheckBackingFieldException() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/checkBackingFieldException.kt"); + doTest(fileName); + } + + @TestMetadata("completeFunctionArgumentsOfNestedCalls.kt") + public void testCompleteFunctionArgumentsOfNestedCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/completeFunctionArgumentsOfNestedCalls.kt"); + doTest(fileName); + } + + @TestMetadata("declarationAfterDotSelectorExpected.kt") + public void testDeclarationAfterDotSelectorExpected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/declarationAfterDotSelectorExpected.kt"); + doTest(fileName); + } + + @TestMetadata("declarationAfterIncompleteElvis.kt") + public void testDeclarationAfterIncompleteElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/declarationAfterIncompleteElvis.kt"); + doTest(fileName); + } + + @TestMetadata("funEquals.kt") + public void testFunEquals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funEquals.kt"); + doTest(fileName); + } + + @TestMetadata("funKeyword.kt") + public void testFunKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("funcitonTypes.kt") + public void testFuncitonTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funcitonTypes.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteEnumReference.kt") + public void testIncompleteEnumReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteEnumReference.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteVal.kt") + public void testIncompleteVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteVal.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteValWithAccessor.kt") + public void testIncompleteValWithAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteValWithAccessor.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteWhen.kt") + public void testIncompleteWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteWhen.kt"); + doTest(fileName); + } + + @TestMetadata("namedFun.kt") + public void testNamedFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/namedFun.kt"); + doTest(fileName); + } + + @TestMetadata("noTypeParamsInReturnType.kt") + public void testNoTypeParamsInReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("typeReferenceError.kt") + public void testTypeReferenceError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt"); + doTest(fileName); + } + + @TestMetadata("valNoName.kt") + public void testValNoName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valNoName.kt"); + doTest(fileName); + } + + @TestMetadata("valWithNoNameBeforeNextDeclarationWithModifiers.kt") + public void testValWithNoNameBeforeNextDeclarationWithModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameBeforeNextDeclarationWithModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("valWithNoNameInBlock.kt") + public void testValWithNoNameInBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inference extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("cannotCompleteResolveAmbiguity.kt") + public void testCannotCompleteResolveAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("cannotCompleteResolveFunctionLiteralsNoUse.kt") + public void testCannotCompleteResolveFunctionLiteralsNoUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt"); + doTest(fileName); + } + + @TestMetadata("cannotCompleteResolveNoInfoForParameter.kt") + public void testCannotCompleteResolveNoInfoForParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt"); + doTest(fileName); + } + + @TestMetadata("cannotCompleteResolveNoneApplicable.kt") + public void testCannotCompleteResolveNoneApplicable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoneApplicable.kt"); + doTest(fileName); + } + + @TestMetadata("cannotCompleteResolveWithFunctionLiterals.kt") + public void testCannotCompleteResolveWithFunctionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("completeInferenceIfManyFailed.kt") + public void testCompleteInferenceIfManyFailed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingSubstitutions.kt") + public void testConflictingSubstitutions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt"); + doTest(fileName); + } + + @TestMetadata("dependOnExpectedType.kt") + public void testDependOnExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/dependOnExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("dependantOnVariance.kt") + public void testDependantOnVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt"); + doTest(fileName); + } + + @TestMetadata("dependantOnVarianceNullable.kt") + public void testDependantOnVarianceNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/dependantOnVarianceNullable.kt"); + doTest(fileName); + } + + @TestMetadata("fixVariableToNothing.kt") + public void testFixVariableToNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/fixVariableToNothing.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleTypesAsUpperBound.kt") + public void testFlexibleTypesAsUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/flexibleTypesAsUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("functionPlaceholderError.kt") + public void testFunctionPlaceholderError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt"); + doTest(fileName); + } + + @TestMetadata("hasErrorInConstrainingTypes.kt") + public void testHasErrorInConstrainingTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.kt"); + doTest(fileName); + } + + @TestMetadata("immutableArrayList.kt") + public void testImmutableArrayList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/immutableArrayList.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeExtensionWithFunctionalArgument.kt") + public void testImplicitInvokeExtensionWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeInObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt"); + doTest(fileName); + } + + @TestMetadata("inferInFunctionLiterals.kt") + public void testInferInFunctionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/inferInFunctionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("inferInFunctionLiteralsWithReturn.kt") + public void testInferInFunctionLiteralsWithReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/inferInFunctionLiteralsWithReturn.kt"); + doTest(fileName); + } + + @TestMetadata("intersectionTypeMultipleBoundsAsReceiver.kt") + public void testIntersectionTypeMultipleBoundsAsReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/intersectionTypeMultipleBoundsAsReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("kt1293.kt") + public void testKt1293() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/kt1293.kt"); + doTest(fileName); + } + + @TestMetadata("kt3184.kt") + public void testKt3184() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/kt3184.kt"); + doTest(fileName); + } + + @TestMetadata("kt6175.kt") + public void testKt6175() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/kt6175.kt"); + doTest(fileName); + } + + @TestMetadata("kt619.kt") + public void testKt619() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/kt619.kt"); + doTest(fileName); + } + + @TestMetadata("listConstructor.kt") + public void testListConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/listConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("mapFunction.kt") + public void testMapFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/mapFunction.kt"); + doTest(fileName); + } + + @TestMetadata("mostSpecificAfterInference.kt") + public void testMostSpecificAfterInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.kt"); + doTest(fileName); + } + + @TestMetadata("NoInferenceFromDeclaredBounds.kt") + public void testNoInferenceFromDeclaredBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt"); + doTest(fileName); + } + + @TestMetadata("noInformationForParameter.kt") + public void testNoInformationForParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt"); + doTest(fileName); + } + + @TestMetadata("nullableTypeArgumentWithNotNullUpperBound.kt") + public void testNullableTypeArgumentWithNotNullUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nullableTypeArgumentWithNotNullUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("nullableUpperBound.kt") + public void testNullableUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nullableUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("opposite.kt") + public void testOpposite() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/opposite.kt"); + doTest(fileName); + } + + @TestMetadata("possibleCycleOnConstraints.kt") + public void testPossibleCycleOnConstraints() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt"); + doTest(fileName); + } + + @TestMetadata("tryNumberLowerBoundsBeforeUpperBounds.kt") + public void testTryNumberLowerBoundsBeforeUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/tryNumberLowerBoundsBeforeUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("typeConstructorMismatch.kt") + public void testTypeConstructorMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("typeInferenceExpectedTypeMismatch.kt") + public void testTypeInferenceExpectedTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("useFunctionLiteralsToInferType.kt") + public void testUseFunctionLiteralsToInferType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/useFunctionLiteralsToInferType.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CapturedTypes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCapturedTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("approximateBeforeFixation.kt") + public void testApproximateBeforeFixation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/approximateBeforeFixation.kt"); + doTest(fileName); + } + + @TestMetadata("cannotCaptureInProjection.kt") + public void testCannotCaptureInProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt"); + doTest(fileName); + } + + @TestMetadata("captureForNullableTypes.kt") + public void testCaptureForNullableTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt"); + doTest(fileName); + } + + @TestMetadata("captureForPlatformTypes.kt") + public void testCaptureForPlatformTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/captureForPlatformTypes.kt"); + doTest(fileName); + } + + @TestMetadata("captureFromNullableTypeVariable.kt") + public void testCaptureFromNullableTypeVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt"); + doTest(fileName); + } + + @TestMetadata("captureFromSubtyping.kt") + public void testCaptureFromSubtyping() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromSubtyping.kt"); + doTest(fileName); + } + + @TestMetadata("captureFromTypeParameterUpperBound.kt") + public void testCaptureFromTypeParameterUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("captureTypeOnlyOnTopLevel.kt") + public void testCaptureTypeOnlyOnTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("capturedType.kt") + public void testCapturedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedType.kt"); + doTest(fileName); + } + + @TestMetadata("capturedTypeAndApproximation.kt") + public void testCapturedTypeAndApproximation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeAndApproximation.kt"); + doTest(fileName); + } + + @TestMetadata("capturedTypeSubstitutedIntoOppositeProjection.kt") + public void testCapturedTypeSubstitutedIntoOppositeProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeSubstitutedIntoOppositeProjection.kt"); + doTest(fileName); + } + + @TestMetadata("expectedTypeMismatchWithInVariance.kt") + public void testExpectedTypeMismatchWithInVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt"); + doTest(fileName); + } + + @TestMetadata("kt2570.kt") + public void testKt2570() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/kt2570.kt"); + doTest(fileName); + } + + @TestMetadata("kt2872.kt") + public void testKt2872() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt"); + doTest(fileName); + } + + @TestMetadata("memberScopeOfCaptured.kt") + public void testMemberScopeOfCaptured() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/memberScopeOfCaptured.kt"); + doTest(fileName); + } + + @TestMetadata("noCaptureTypeErrorForNonTopLevel.kt") + public void testNoCaptureTypeErrorForNonTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("notApproximateWhenCopyDescriptors.kt") + public void testNotApproximateWhenCopyDescriptors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/notApproximateWhenCopyDescriptors.kt"); + doTest(fileName); + } + + @TestMetadata("overApproximationForInCaptured.kt") + public void testOverApproximationForInCaptured() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/overApproximationForInCaptured.kt"); + doTest(fileName); + } + + @TestMetadata("overApproximationForOutCaptured.kt") + public void testOverApproximationForOutCaptured() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/overApproximationForOutCaptured.kt"); + doTest(fileName); + } + + @TestMetadata("starProjectionRegression.kt") + public void testStarProjectionRegression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes/starProjectionRegression.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/commonSystem") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CommonSystem extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCommonSystem() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("boundOnNullableVariable.kt") + public void testBoundOnNullableVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt"); + doTest(fileName); + } + + @TestMetadata("dontCaptureTypeVariable.kt") + public void testDontCaptureTypeVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt"); + doTest(fileName); + } + + @TestMetadata("fixVariablesInRightOrder.kt") + public void testFixVariablesInRightOrder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt"); + doTest(fileName); + } + + @TestMetadata("genericCandidateInGenericClass.kt") + public void testGenericCandidateInGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceWithUpperBoundsInLambda.kt") + public void testInferenceWithUpperBoundsInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("kt3372toCollection.kt") + public void testKt3372toCollection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLambdas.kt") + public void testNestedLambdas() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt"); + doTest(fileName); + } + + @TestMetadata("theSameFunctionInArgs.kt") + public void testTheSameFunctionInArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/constraints") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Constraints extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInConstraints() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("constraintOnFunctionLiteral.kt") + public void testConstraintOnFunctionLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("equalityConstraintOnNullableType.kt") + public void testEqualityConstraintOnNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/equalityConstraintOnNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("ignoreConstraintFromImplicitInNothing.kt") + public void testIgnoreConstraintFromImplicitInNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.kt"); + doTest(fileName); + } + + @TestMetadata("kt6320.kt") + public void testKt6320() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt"); + doTest(fileName); + } + + @TestMetadata("kt7351ConstraintFromUnitExpectedType.kt") + public void testKt7351ConstraintFromUnitExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/kt7351ConstraintFromUnitExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("kt7433.kt") + public void testKt7433() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/kt7433.kt"); + doTest(fileName); + } + + @TestMetadata("kt8879.kt") + public void testKt8879() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt"); + doTest(fileName); + } + + @TestMetadata("notNullConstraintOnNullableType.kt") + public void testNotNullConstraintOnNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("subtypeConstraintOnNullableType.kt") + public void testSubtypeConstraintOnNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/subtypeConstraintOnNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("supertypeConstraintOnNullableType.kt") + public void testSupertypeConstraintOnNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/constraints/supertypeConstraintOnNullableType.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NestedCalls extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNestedCalls() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayAccess.kt") + public void testArrayAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/arrayAccess.kt"); + doTest(fileName); + } + + @TestMetadata("binaryExpressions.kt") + public void testBinaryExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("checkTypesForQualifiedProperties.kt") + public void testCheckTypesForQualifiedProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.kt"); + doTest(fileName); + } + + @TestMetadata("completeNestedCallsForArraySetExpression.kt") + public void testCompleteNestedCallsForArraySetExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedCallsForArraySetExpression.kt"); + doTest(fileName); + } + + @TestMetadata("completeNestedCallsInference.kt") + public void testCompleteNestedCallsInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedCallsInference.kt"); + doTest(fileName); + } + + @TestMetadata("completeNestedForVariableAsFunctionCall.kt") + public void testCompleteNestedForVariableAsFunctionCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedForVariableAsFunctionCall.kt"); + doTest(fileName); + } + + @TestMetadata("externalTypeParameter.kt") + public void testExternalTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/externalTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceForNestedBinaryCall.kt") + public void testInferenceForNestedBinaryCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/inferenceForNestedBinaryCall.kt"); + doTest(fileName); + } + + @TestMetadata("kt3395.kt") + public void testKt3395() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3395.kt"); + doTest(fileName); + } + + @TestMetadata("kt3461checkTypes.kt") + public void testKt3461checkTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.kt"); + doTest(fileName); + } + + @TestMetadata("makeNullableIfSafeCall.kt") + public void testMakeNullableIfSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/makeNullableIfSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("nontrivialCallExpression.kt") + public void testNontrivialCallExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls/nontrivialCallExpression.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class RecursiveLocalFuns extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInRecursiveLocalFuns() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("localFactorial.kt") + public void testLocalFactorial() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveFun.kt") + public void testRecursiveFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveFun.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveLambda.kt") + public void testRecursiveLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.kt"); + doTest(fileName); + } + + @TestMetadata("selfCall.kt") + public void testSelfCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/regressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Regressions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compareBy.kt") + public void testCompareBy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/compareBy.kt"); + doTest(fileName); + } + + @TestMetadata("kt1029.kt") + public void testKt1029() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1029.kt"); + doTest(fileName); + } + + @TestMetadata("kt1031.kt") + public void testKt1031() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1031.kt"); + doTest(fileName); + } + + @TestMetadata("kt1127.kt") + public void testKt1127() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt"); + doTest(fileName); + } + + @TestMetadata("kt1145.kt") + public void testKt1145() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1145.kt"); + doTest(fileName); + } + + @TestMetadata("kt1358.kt") + public void testKt1358() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1358.kt"); + doTest(fileName); + } + + @TestMetadata("kt1410.kt") + public void testKt1410() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1410.kt"); + doTest(fileName); + } + + @TestMetadata("kt1718.kt") + public void testKt1718() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1718.kt"); + doTest(fileName); + } + + @TestMetadata("kt1944.kt") + public void testKt1944() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt1944.kt"); + doTest(fileName); + } + + @TestMetadata("kt2057.kt") + public void testKt2057() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt"); + doTest(fileName); + } + + @TestMetadata("kt2179.kt") + public void testKt2179() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2179.kt"); + doTest(fileName); + } + + @TestMetadata("kt2200.kt") + public void testKt2200() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt"); + doTest(fileName); + } + + @TestMetadata("kt2283.kt") + public void testKt2283() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt"); + doTest(fileName); + } + + @TestMetadata("kt2286.kt") + public void testKt2286() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt"); + doTest(fileName); + } + + @TestMetadata("kt2294.kt") + public void testKt2294() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2294.kt"); + doTest(fileName); + } + + @TestMetadata("kt2320.kt") + public void testKt2320() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2320.kt"); + doTest(fileName); + } + + @TestMetadata("kt2324.kt") + public void testKt2324() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2324.kt"); + doTest(fileName); + } + + @TestMetadata("kt2407.kt") + public void testKt2407() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2407.kt"); + doTest(fileName); + } + + @TestMetadata("kt2445.kt") + public void testKt2445() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt"); + doTest(fileName); + } + + @TestMetadata("kt2459.kt") + public void testKt2459() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2459.kt"); + doTest(fileName); + } + + @TestMetadata("kt2484.kt") + public void testKt2484() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2484.kt"); + doTest(fileName); + } + + @TestMetadata("kt2505.kt") + public void testKt2505() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt"); + doTest(fileName); + } + + @TestMetadata("kt2514.kt") + public void testKt2514() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2514.kt"); + doTest(fileName); + } + + @TestMetadata("kt2588.kt") + public void testKt2588() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt"); + doTest(fileName); + } + + @TestMetadata("kt2741.kt") + public void testKt2741() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt"); + doTest(fileName); + } + + @TestMetadata("kt2754.kt") + public void testKt2754() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt"); + doTest(fileName); + } + + @TestMetadata("kt2838.kt") + public void testKt2838() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt"); + doTest(fileName); + } + + @TestMetadata("kt2841.kt") + public void testKt2841() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt"); + doTest(fileName); + } + + @TestMetadata("kt2841_it.kt") + public void testKt2841_it() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.kt"); + doTest(fileName); + } + + @TestMetadata("kt2841_it_this.kt") + public void testKt2841_it_this() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.kt"); + doTest(fileName); + } + + @TestMetadata("kt2841_this.kt") + public void testKt2841_this() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.kt"); + doTest(fileName); + } + + @TestMetadata("kt2842.kt") + public void testKt2842() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt"); + doTest(fileName); + } + + @TestMetadata("kt2883.kt") + public void testKt2883() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt"); + doTest(fileName); + } + + @TestMetadata("kt3007.kt") + public void testKt3007() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3007.kt"); + doTest(fileName); + } + + @TestMetadata("kt3038.kt") + public void testKt3038() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3038.kt"); + doTest(fileName); + } + + @TestMetadata("kt3150.kt") + public void testKt3150() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3150.kt"); + doTest(fileName); + } + + @TestMetadata("kt3174.kt") + public void testKt3174() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3174.kt"); + doTest(fileName); + } + + @TestMetadata("kt3301.kt") + public void testKt3301() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3301.kt"); + doTest(fileName); + } + + @TestMetadata("kt3344.kt") + public void testKt3344() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3344.kt"); + doTest(fileName); + } + + @TestMetadata("kt3496.kt") + public void testKt3496() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt"); + doTest(fileName); + } + + @TestMetadata("kt3496_2.kt") + public void testKt3496_2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt"); + doTest(fileName); + } + + @TestMetadata("kt3559.kt") + public void testKt3559() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt"); + doTest(fileName); + } + + @TestMetadata("kt4420.kt") + public void testKt4420() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt"); + doTest(fileName); + } + + @TestMetadata("kt702.kt") + public void testKt702() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt702.kt"); + doTest(fileName); + } + + @TestMetadata("kt731.kt") + public void testKt731() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt731.kt"); + doTest(fileName); + } + + @TestMetadata("kt742.kt") + public void testKt742() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt742.kt"); + doTest(fileName); + } + + @TestMetadata("kt8132.kt") + public void testKt8132() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt"); + doTest(fileName); + } + + @TestMetadata("kt832.kt") + public void testKt832() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt832.kt"); + doTest(fileName); + } + + @TestMetadata("kt943.kt") + public void testKt943() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt943.kt"); + doTest(fileName); + } + + @TestMetadata("kt9461.kt") + public void testKt9461() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt9461.kt"); + doTest(fileName); + } + + @TestMetadata("kt948.kt") + public void testKt948() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/kt948.kt"); + doTest(fileName); + } + + @TestMetadata("noRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor.kt") + public void testNoRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/regressions/noRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ReportingImprovements extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInReportingImprovements() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("cannotInferParameterTypeWithInference.kt") + public void testCannotInferParameterTypeWithInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt"); + doTest(fileName); + } + + @TestMetadata("ErrorTypeAsGenericParameter.kt") + public void testErrorTypeAsGenericParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionPlaceholder.kt") + public void testFunctionPlaceholder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt"); + doTest(fileName); + } + + @TestMetadata("NoAmbiguityForDifferentFunctionTypes.kt") + public void testNoAmbiguityForDifferentFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("subtypeForInvariantWithErrorGenerics.kt") + public void testSubtypeForInvariantWithErrorGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("wrongArgumentExtensionFunction.kt") + public void testWrongArgumentExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.kt"); + doTest(fileName); + } + + @TestMetadata("wrongArgumentPassedToLocalExtensionFunction.kt") + public void testWrongArgumentPassedToLocalExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/substitutions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Substitutions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSubstitutions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegationAndInference.kt") + public void testDelegationAndInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt"); + doTest(fileName); + } + + @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt") + public void testKt6081SubstituteIntoClassCorrectly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt"); + doTest(fileName); + } + + @TestMetadata("simpleSubstitutionCheckTypeArgumentsNotTypeParameters.kt") + public void testSimpleSubstitutionCheckTypeArgumentsNotTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("substitutionIntoAnonymousClass.kt") + public void testSubstitutionIntoAnonymousClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.kt"); + doTest(fileName); + } + + @TestMetadata("substitutionIntoInnerClass.kt") + public void testSubstitutionIntoInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inference/upperBounds") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class UpperBounds extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInUpperBounds() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("conflictingSubstitutionsFromUpperBound.kt") + public void testConflictingSubstitutionsFromUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("doNotInferFromBoundsOnly.kt") + public void testDoNotInferFromBoundsOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt"); + doTest(fileName); + } + + @TestMetadata("intersectUpperBounds.kt") + public void testIntersectUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("kt2856.kt") + public void testKt2856() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.kt"); + doTest(fileName); + } + + @TestMetadata("nonNullUpperBound.kt") + public void testNonNullUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/nonNullUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("useBoundsIfUnknownParameters.kt") + public void testUseBoundsIfUnknownParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt"); + doTest(fileName); + } + + @TestMetadata("useBoundsToInferTypeParamsSimple.kt") + public void testUseBoundsToInferTypeParamsSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/infos") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Infos extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInfos() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("PropertiesWithBackingFields.kt") + public void testPropertiesWithBackingFields() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt"); + doTest(fileName); + } + + @TestMetadata("SmartCasts.kt") + public void testSmartCasts() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/infos/SmartCasts.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inline extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("anonymousObjects.kt") + public void testAnonymousObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/anonymousObjects.kt"); + doTest(fileName); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("capture.kt") + public void testCapture() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/capture.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("default.kt") + public void testDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/default.kt"); + doTest(fileName); + } + + @TestMetadata("defaultLambdaInlineDisable.kt") + public void testDefaultLambdaInlineDisable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/defaultLambdaInlineDisable.kt"); + doTest(fileName); + } + + @TestMetadata("defaultLambdaInlining.kt") + public void testDefaultLambdaInlining() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/defaultLambdaInlining.kt"); + doTest(fileName); + } + + @TestMetadata("extensionOnFunction.kt") + public void testExtensionOnFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/extensionOnFunction.kt"); + doTest(fileName); + } + + @TestMetadata("fromInlineToNoInline.kt") + public void testFromInlineToNoInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.kt"); + doTest(fileName); + } + + @TestMetadata("functions.kt") + public void testFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/functions.kt"); + doTest(fileName); + } + + @TestMetadata("inlineLambdaInDefaultInlineParameter.kt") + public void testInlineLambdaInDefaultInlineParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameter.kt"); + doTest(fileName); + } + + @TestMetadata("inlineLambdaInDefaultInlineParameterDisabled.kt") + public void testInlineLambdaInDefaultInlineParameterDisabled() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameterDisabled.kt"); + doTest(fileName); + } + + @TestMetadata("inlineReified.kt") + public void testInlineReified() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/inlineReified.kt"); + doTest(fileName); + } + + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/invoke.kt"); + doTest(fileName); + } + + @TestMetadata("isCheck.kt") + public void testIsCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/isCheck.kt"); + doTest(fileName); + } + + @TestMetadata("kt15410.kt") + public void testKt15410() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/kt15410.kt"); + doTest(fileName); + } + + @TestMetadata("kt4869.kt") + public void testKt4869() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/kt4869.kt"); + doTest(fileName); + } + + @TestMetadata("labeled.kt") + public void testLabeled() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/labeled.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaCast.kt") + public void testLambdaCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/lambdaCast.kt"); + doTest(fileName); + } + + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/localFun.kt"); + doTest(fileName); + } + + @TestMetadata("nonVirtualMembersWithInline.kt") + public void testNonVirtualMembersWithInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.kt"); + doTest(fileName); + } + + @TestMetadata("nothingToInline.kt") + public void testNothingToInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nothingToInline.kt"); + doTest(fileName); + } + + @TestMetadata("nullabilityOperations.kt") + public void testNullabilityOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nullabilityOperations.kt"); + doTest(fileName); + } + + @TestMetadata("nullableFunction.kt") + public void testNullableFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nullableFunction.kt"); + doTest(fileName); + } + + @TestMetadata("overrideWithInline.kt") + public void testOverrideWithInline() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/overrideWithInline.kt"); + doTest(fileName); + } + + @TestMetadata("parenthesized.kt") + public void testParenthesized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/parenthesized.kt"); + doTest(fileName); + } + + @TestMetadata("privateClass.kt") + public void testPrivateClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/privateClass.kt"); + doTest(fileName); + } + + @TestMetadata("propagation.kt") + public void testPropagation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/propagation.kt"); + doTest(fileName); + } + + @TestMetadata("protectedDepecation.kt") + public void testProtectedDepecation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/protectedDepecation.kt"); + doTest(fileName); + } + + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/publishedApi.kt"); + doTest(fileName); + } + + @TestMetadata("recursion.kt") + public void testRecursion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/recursion.kt"); + doTest(fileName); + } + + @TestMetadata("returns.kt") + public void testReturns() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/returns.kt"); + doTest(fileName); + } + + @TestMetadata("sam.kt") + public void testSam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/sam.kt"); + doTest(fileName); + } + + @TestMetadata("stringTemplate.kt") + public void testStringTemplate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/stringTemplate.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedConstruction.kt") + public void testUnsupportedConstruction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/unsupportedConstruction.kt"); + doTest(fileName); + } + + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/vararg.kt"); + doTest(fileName); + } + + @TestMetadata("when.kt") + public void testWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/when.kt"); + doTest(fileName); + } + + @TestMetadata("wrongUsage.kt") + public void testWrongUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/wrongUsage.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class BinaryExpressions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInBinaryExpressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("andOr.kt") + public void testAndOr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.kt"); + doTest(fileName); + } + + @TestMetadata("arrayAccess.kt") + public void testArrayAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.kt"); + doTest(fileName); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("comparison.kt") + public void testComparison() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.kt"); + doTest(fileName); + } + + @TestMetadata("componentAccess.kt") + public void testComponentAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.kt"); + doTest(fileName); + } + + @TestMetadata("contains.kt") + public void testContains() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.kt"); + doTest(fileName); + } + + @TestMetadata("mathOperations.kt") + public void testMathOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.kt"); + doTest(fileName); + } + + @TestMetadata("rangeTo.kt") + public void testRangeTo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonLocalReturns extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNonLocalReturns() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("anonymousObjects.kt") + public void testAnonymousObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.kt"); + doTest(fileName); + } + + @TestMetadata("anonymousObjectsNested.kt") + public void testAnonymousObjectsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.kt"); + doTest(fileName); + } + + @TestMetadata("explicitReturnType.kt") + public void testExplicitReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("fromOnlyLocal.kt") + public void testFromOnlyLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.kt"); + doTest(fileName); + } + + @TestMetadata("inlineLambda.kt") + public void testInlineLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.kt"); + doTest(fileName); + } + + @TestMetadata("labeledReturn.kt") + public void testLabeledReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaAsGeneric.kt") + public void testLambdaAsGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaAsNonFunction.kt") + public void testLambdaAsNonFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaWithGlobalReturnsInsideOnlyLocalOne.kt") + public void testLambdaWithGlobalReturnsInsideOnlyLocalOne() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.kt"); + doTest(fileName); + } + + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.kt"); + doTest(fileName); + } + + @TestMetadata("nestedNonLocals.kt") + public void testNestedNonLocals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.kt"); + doTest(fileName); + } + + @TestMetadata("noInlineAnnotation.kt") + public void testNoInlineAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.kt"); + doTest(fileName); + } + + @TestMetadata("nonInlinedClass.kt") + public void testNonInlinedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.kt"); + doTest(fileName); + } + + @TestMetadata("onlyLocalReturnLambda.kt") + public void testOnlyLocalReturnLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.kt"); + doTest(fileName); + } + + @TestMetadata("onlyLocalReturnLambdaBinaryExpr.kt") + public void testOnlyLocalReturnLambdaBinaryExpr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAccessorsAndConstructor.kt") + public void testPropertyAccessorsAndConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("toOnlyLocal.kt") + public void testToOnlyLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonPublicMember extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNonPublicMember() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("inNonPublicClass.kt") + public void testInNonPublicClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.kt"); + doTest(fileName); + } + + @TestMetadata("inNonPublicInnerClass.kt") + public void testInNonPublicInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("inPackage.kt") + public void testInPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.kt"); + doTest(fileName); + } + + @TestMetadata("inPublicClass.kt") + public void testInPublicClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.kt"); + doTest(fileName); + } + + @TestMetadata("kt14887.kt") + public void testKt14887() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/kt14887.kt"); + doTest(fileName); + } + + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/localClass.kt"); + doTest(fileName); + } + + @TestMetadata("localClass2.kt") + public void testLocalClass2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/localClass2.kt"); + doTest(fileName); + } + + @TestMetadata("localFun.kt") + public void testLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/localFun.kt"); + doTest(fileName); + } + + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline/property") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Property extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/property/invoke.kt"); + doTest(fileName); + } + + @TestMetadata("propertyWithBackingField.kt") + public void testPropertyWithBackingField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedConstruction.kt") + public void testUnsupportedConstruction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/property/unsupportedConstruction.kt"); + doTest(fileName); + } + + @TestMetadata("virtualProperty.kt") + public void testVirtualProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/property/virtualProperty.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline/regressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Regressions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt4341.kt") + public void testKt4341() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/regressions/kt4341.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class UnaryExpressions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInUnaryExpressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("mathOperation.kt") + public void testMathOperation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.kt"); + doTest(fileName); + } + + @TestMetadata("notOnCall.kt") + public void testNotOnCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.kt"); + doTest(fileName); + } + + @TestMetadata("notOperation.kt") + public void testNotOperation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/inner") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inner extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accessingToJavaNestedClass.kt") + public void testAccessingToJavaNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/accessingToJavaNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("accessingToKotlinNestedClass.kt") + public void testAccessingToKotlinNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/accessingToKotlinNestedClass.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInInner() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classesInClassObjectHeader.kt") + public void testClassesInClassObjectHeader() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt"); + doTest(fileName); + } + + @TestMetadata("constructorAccess.kt") + public void testConstructorAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/constructorAccess.kt"); + doTest(fileName); + } + + @TestMetadata("deepInnerClass.kt") + public void testDeepInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/deepInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("enumEntries.kt") + public void testEnumEntries() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/enumEntries.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFun.kt") + public void testExtensionFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/extensionFun.kt"); + doTest(fileName); + } + + @TestMetadata("extensionLambdaInsideNestedClass.kt") + public void testExtensionLambdaInsideNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/extensionLambdaInsideNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("illegalModifier.kt") + public void testIllegalModifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/illegalModifier.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassNameClash.kt") + public void testInnerClassNameClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/InnerClassNameClash.kt"); + doTest(fileName); + } + + @TestMetadata("innerClassesInStaticParameters.kt") + public void testInnerClassesInStaticParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt"); + doTest(fileName); + } + + @TestMetadata("innerConstructorsFromQualifiers.kt") + public void testInnerConstructorsFromQualifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiers.kt"); + doTest(fileName); + } + + @TestMetadata("innerConstructorsFromQualifiersWithIrrelevantCandidate.kt") + public void testInnerConstructorsFromQualifiersWithIrrelevantCandidate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.kt"); + doTest(fileName); + } + + @TestMetadata("innerErrorForClassObjects.kt") + public void testInnerErrorForClassObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt"); + doTest(fileName); + } + + @TestMetadata("innerErrorForObjects.kt") + public void testInnerErrorForObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt"); + doTest(fileName); + } + + @TestMetadata("innerThisSuper.kt") + public void testInnerThisSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/innerThisSuper.kt"); + doTest(fileName); + } + + @TestMetadata("kt5854.kt") + public void testKt5854() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/kt5854.kt"); + doTest(fileName); + } + + @TestMetadata("kt6026.kt") + public void testKt6026() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/kt6026.kt"); + doTest(fileName); + } + + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/localClass.kt"); + doTest(fileName); + } + + @TestMetadata("localClassInsideNested.kt") + public void testLocalClassInsideNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/localClassInsideNested.kt"); + doTest(fileName); + } + + @TestMetadata("localThisSuper.kt") + public void testLocalThisSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/localThisSuper.kt"); + doTest(fileName); + } + + @TestMetadata("modality.kt") + public void testModality() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/modality.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassAccessedViaInstanceReference.kt") + public void testNestedClassAccessedViaInstanceReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassExtendsOuter.kt") + public void testNestedClassExtendsOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuter.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassExtendsOuterGeneric.kt") + public void testNestedClassExtendsOuterGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuterGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassInObject.kt") + public void testNestedClassInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedClassInObject.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassNotAllowed.kt") + public void testNestedClassNotAllowed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed.kt"); + doTest(fileName); + } + + @TestMetadata("nestedObject.kt") + public void testNestedObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedObject.kt"); + doTest(fileName); + } + + @TestMetadata("nestedVsInnerAccessOuterMember.kt") + public void testNestedVsInnerAccessOuterMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/nestedVsInnerAccessOuterMember.kt"); + doTest(fileName); + } + + @TestMetadata("outerGenericParam.kt") + public void testOuterGenericParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/outerGenericParam.kt"); + doTest(fileName); + } + + @TestMetadata("outerProtectedMember.kt") + public void testOuterProtectedMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/outerProtectedMember.kt"); + doTest(fileName); + } + + @TestMetadata("outerSuperClassMember.kt") + public void testOuterSuperClassMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/outerSuperClassMember.kt"); + doTest(fileName); + } + + @TestMetadata("referenceToSelfInLocal.kt") + public void testReferenceToSelfInLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/referenceToSelfInLocal.kt"); + doTest(fileName); + } + + @TestMetadata("resolvePackageClassInObjects.kt") + public void testResolvePackageClassInObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt"); + doTest(fileName); + } + + @TestMetadata("selfAnnotationForClassObject.kt") + public void testSelfAnnotationForClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("traits.kt") + public void testTraits() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/traits.kt"); + doTest(fileName); + } + + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/visibility.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class QualifiedExpression extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classObjectOfNestedClass.kt") + public void testClassObjectOfNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/classObjectOfNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("constructNestedClass.kt") + public void testConstructNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/constructNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("dataLocalVariable.kt") + public void testDataLocalVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/dataLocalVariable.kt"); + doTest(fileName); + } + + @TestMetadata("enumConstant.kt") + public void testEnumConstant() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/enumConstant.kt"); + doTest(fileName); + } + + @TestMetadata("genericNestedClass.kt") + public void testGenericNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("importNestedClass.kt") + public void testImportNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/importNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassInPackage.kt") + public void testNestedClassInPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedClassInPackage.kt"); + doTest(fileName); + } + + @TestMetadata("nestedEnumConstant.kt") + public void testNestedEnumConstant() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedEnumConstant.kt"); + doTest(fileName); + } + + @TestMetadata("nestedObjects.kt") + public void testNestedObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedObjects.kt"); + doTest(fileName); + } + + @TestMetadata("typePosition.kt") + public void testTypePosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression/typePosition.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class J_k extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accessClassObjectFromJava.kt") + public void testAccessClassObjectFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/accessClassObjectFromJava.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInJ_k() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguousSamAdapters.kt") + public void testAmbiguousSamAdapters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/ambiguousSamAdapters.kt"); + doTest(fileName); + } + + @TestMetadata("annotationWithArgumentsMissingDependencies.kt") + public void testAnnotationWithArgumentsMissingDependencies() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt"); + doTest(fileName); + } + + @TestMetadata("arrayOfStarParametrized.kt") + public void testArrayOfStarParametrized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/arrayOfStarParametrized.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferencesStaticMemberClash.kt") + public void testCallableReferencesStaticMemberClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/callableReferencesStaticMemberClash.kt"); + doTest(fileName); + } + + @TestMetadata("canDeclareIfSamAdapterIsInherited.kt") + public void testCanDeclareIfSamAdapterIsInherited() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/canDeclareIfSamAdapterIsInherited.kt"); + doTest(fileName); + } + + @TestMetadata("computeIfAbsentConcurrent.kt") + public void testComputeIfAbsentConcurrent() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt"); + doTest(fileName); + } + + @TestMetadata("contravariantIterable.kt") + public void testContravariantIterable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/contravariantIterable.kt"); + doTest(fileName); + } + + @TestMetadata("differentFilename.kt") + public void testDifferentFilename() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/differentFilename.kt"); + doTest(fileName); + } + + @TestMetadata("enumGetOrdinal.kt") + public void testEnumGetOrdinal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/enumGetOrdinal.kt"); + doTest(fileName); + } + + @TestMetadata("fieldOverridesField.kt") + public void testFieldOverridesField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/fieldOverridesField.kt"); + doTest(fileName); + } + + @TestMetadata("fieldOverridesFieldOfDifferentType.kt") + public void testFieldOverridesFieldOfDifferentType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/fieldOverridesFieldOfDifferentType.kt"); + doTest(fileName); + } + + @TestMetadata("fieldOverridesNothing.kt") + public void testFieldOverridesNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/fieldOverridesNothing.kt"); + doTest(fileName); + } + + @TestMetadata("finalCollectionSize.kt") + public void testFinalCollectionSize() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt"); + doTest(fileName); + } + + @TestMetadata("genericConstructorWithMultipleBounds.kt") + public void testGenericConstructorWithMultipleBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt"); + doTest(fileName); + } + + @TestMetadata("GenericsInSupertypes.kt") + public void testGenericsInSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("inheritAbstractSamAdapter.kt") + public void testInheritAbstractSamAdapter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/inheritAbstractSamAdapter.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedGenericFunction.kt") + public void testInheritedGenericFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassFromJava.kt") + public void testInnerClassFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/InnerClassFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("innerNestedClassFromJava.kt") + public void testInnerNestedClassFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("invisiblePackagePrivateInheritedMember.kt") + public void testInvisiblePackagePrivateInheritedMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.kt"); + doTest(fileName); + } + + @TestMetadata("javaStaticImport.kt") + public void testJavaStaticImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt"); + doTest(fileName); + } + + @TestMetadata("KJKInheritance.kt") + public void testKJKInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/KJKInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("KJKInheritanceGeneric.kt") + public void testKJKInheritanceGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/KJKInheritanceGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("kt1402.kt") + public void testKt1402() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt1402.kt"); + doTest(fileName); + } + + @TestMetadata("kt1431.kt") + public void testKt1431() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt1431.kt"); + doTest(fileName); + } + + @TestMetadata("kt1730_implementCharSequence.kt") + public void testKt1730_implementCharSequence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.kt"); + doTest(fileName); + } + + @TestMetadata("kt2152.kt") + public void testKt2152() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt2152.kt"); + doTest(fileName); + } + + @TestMetadata("kt2394.kt") + public void testKt2394() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt2394.kt"); + doTest(fileName); + } + + @TestMetadata("kt2606.kt") + public void testKt2606() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt2606.kt"); + doTest(fileName); + } + + @TestMetadata("kt2619.kt") + public void testKt2619() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt2619.kt"); + doTest(fileName); + } + + @TestMetadata("kt2641.kt") + public void testKt2641() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt2641.kt"); + doTest(fileName); + } + + @TestMetadata("kt2890.kt") + public void testKt2890() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt2890.kt"); + doTest(fileName); + } + + @TestMetadata("kt3307.kt") + public void testKt3307() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt3307.kt"); + doTest(fileName); + } + + @TestMetadata("kt3311.kt") + public void testKt3311() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt3311.kt"); + doTest(fileName); + } + + @TestMetadata("kt6720_abstractProperty.kt") + public void testKt6720_abstractProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt6720_abstractProperty.kt"); + doTest(fileName); + } + + @TestMetadata("kt7523.kt") + public void testKt7523() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/kt7523.kt"); + doTest(fileName); + } + + @TestMetadata("matchers.kt") + public void testMatchers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/matchers.kt"); + doTest(fileName); + } + + @TestMetadata("mutableIterator.kt") + public void testMutableIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/mutableIterator.kt"); + doTest(fileName); + } + + @TestMetadata("overrideRawType.kt") + public void testOverrideRawType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/overrideRawType.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideVararg.kt") + public void testOverrideVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/OverrideVararg.kt"); + doTest(fileName); + } + + @TestMetadata("overrideWithSamAndTypeParameter.kt") + public void testOverrideWithSamAndTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("packagePrivateClassStaticMember.kt") + public void testPackagePrivateClassStaticMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/packagePrivateClassStaticMember.kt"); + doTest(fileName); + } + + @TestMetadata("packageVisibility.kt") + public void testPackageVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/packageVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("privateFieldOverridesNothing.kt") + public void testPrivateFieldOverridesNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/privateFieldOverridesNothing.kt"); + doTest(fileName); + } + + @TestMetadata("privateNestedClassStaticMember.kt") + public void testPrivateNestedClassStaticMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt"); + doTest(fileName); + } + + @TestMetadata("protectedStaticSamePackage.kt") + public void testProtectedStaticSamePackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/protectedStaticSamePackage.kt"); + doTest(fileName); + } + + @TestMetadata("recursionWithJavaSyntheticProperty.kt") + public void testRecursionWithJavaSyntheticProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveRawUpperBound.kt") + public void testRecursiveRawUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveRawUpperBound2.kt") + public void testRecursiveRawUpperBound2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound2.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveRawUpperBound3.kt") + public void testRecursiveRawUpperBound3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound3.kt"); + doTest(fileName); + } + + @TestMetadata("samInConstructorWithGenerics.kt") + public void testSamInConstructorWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("selectMoreSpecific.kt") + public void testSelectMoreSpecific() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/selectMoreSpecific.kt"); + doTest(fileName); + } + + @TestMetadata("serializable.kt") + public void testSerializable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/serializable.kt"); + doTest(fileName); + } + + @TestMetadata("shadowingPrimitiveStaticField.kt") + public void testShadowingPrimitiveStaticField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt"); + doTest(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/Simple.kt"); + doTest(fileName); + } + + @TestMetadata("specialBridges.kt") + public void testSpecialBridges() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/specialBridges.kt"); + doTest(fileName); + } + + @TestMetadata("StaticMembersFromSuperclasses.kt") + public void testStaticMembersFromSuperclasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeArgumentsNullability-NotNull-SpecialTypes.kt") + public void testSupertypeArgumentsNullability_NotNull_SpecialTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeArgumentsNullability-NotNull-UserTypes.kt") + public void testSupertypeArgumentsNullability_NotNull_UserTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeArgumentsNullability-SpecialTypes.kt") + public void testSupertypeArgumentsNullability_SpecialTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-SpecialTypes.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeArgumentsNullability-UserTypes.kt") + public void testSupertypeArgumentsNullability_UserTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-UserTypes.kt"); + doTest(fileName); + } + + @TestMetadata("traitDefaultCall.kt") + public void testTraitDefaultCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/traitDefaultCall.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasWithSamConstructor.kt") + public void testTypeAliasWithSamConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/typeAliasWithSamConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("UnboxingNulls.kt") + public void testUnboxingNulls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/UnboxingNulls.kt"); + doTest(fileName); + } + + @TestMetadata("wrongVarianceInJava.kt") + public void testWrongVarianceInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/brokenCode") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class BrokenCode extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInBrokenCode() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classDuplicates.kt") + public void testClassDuplicates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/brokenCode/classDuplicates.kt"); + doTest(fileName); + } + + @TestMetadata("fieldDuplicates.kt") + public void testFieldDuplicates() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/brokenCode/fieldDuplicates.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CollectionOverrides extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCollectionOverrides() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("charBuffer.kt") + public void testCharBuffer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/charBuffer.kt"); + doTest(fileName); + } + + @TestMetadata("collectionStringImpl.kt") + public void testCollectionStringImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/collectionStringImpl.kt"); + doTest(fileName); + } + + @TestMetadata("commonCollections.kt") + public void testCommonCollections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.kt"); + doTest(fileName); + } + + @TestMetadata("contains.kt") + public void testContains() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt"); + doTest(fileName); + } + + @TestMetadata("containsAll.kt") + public void testContainsAll() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt"); + doTest(fileName); + } + + @TestMetadata("containsAndOverload.kt") + public void testContainsAndOverload() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.kt"); + doTest(fileName); + } + + @TestMetadata("getCharSequence.kt") + public void testGetCharSequence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/getCharSequence.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantCharAtAbstract.kt") + public void testIrrelevantCharAtAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantCharAtAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantImplCharSequence.kt") + public void testIrrelevantImplCharSequence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplCharSequence.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantImplCharSequenceKotlin.kt") + public void testIrrelevantImplCharSequenceKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplCharSequenceKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantImplMutableList.kt") + public void testIrrelevantImplMutableList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplMutableList.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantImplMutableListKotlin.kt") + public void testIrrelevantImplMutableListKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplMutableListKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("irrelevantMapGetAbstract.kt") + public void testIrrelevantMapGetAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantMapGetAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("mapGetOverride.kt") + public void testMapGetOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt"); + doTest(fileName); + } + + @TestMetadata("overridesBuiltinNoMagic.kt") + public void testOverridesBuiltinNoMagic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/overridesBuiltinNoMagic.kt"); + doTest(fileName); + } + + @TestMetadata("removeAt.kt") + public void testRemoveAt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt"); + doTest(fileName); + } + + @TestMetadata("removeAtInt.kt") + public void testRemoveAtInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt"); + doTest(fileName); + } + + @TestMetadata("sizeFromKotlinOverriddenInJava.kt") + public void testSizeFromKotlinOverriddenInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides/sizeFromKotlinOverriddenInJava.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class GenericConstructor extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInGenericConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classTypeParameterInferredFromArgument.kt") + public void testClassTypeParameterInferredFromArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt"); + doTest(fileName); + } + + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt"); + doTest(fileName); + } + + @TestMetadata("noClassTypeParameters.kt") + public void testNoClassTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("noClassTypeParametersInvParameter.kt") + public void testNoClassTypeParametersInvParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt"); + doTest(fileName); + } + + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt"); + doTest(fileName); + } + + @TestMetadata("selfTypes.kt") + public void testSelfTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/selfTypes.kt"); + doTest(fileName); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt"); + doTest(fileName); + } + + @TestMetadata("superCallImpossibleToInfer.kt") + public void testSuperCallImpossibleToInfer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt"); + doTest(fileName); + } + + @TestMetadata("withClassTypeParameters.kt") + public void testWithClassTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrimitiveOverrides extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInPrimitiveOverrides() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt11140.kt") + public void testKt11140() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt"); + doTest(fileName); + } + + @TestMetadata("notNullAnnotated.kt") + public void testNotNullAnnotated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/notNullAnnotated.kt"); + doTest(fileName); + } + + @TestMetadata("specializedMap.kt") + public void testSpecializedMap() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/properties") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Properties extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInProperties() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("interface.kt") + public void testInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/properties/interface.kt"); + doTest(fileName); + } + + @TestMetadata("isName.kt") + public void testIsName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/properties/isName.kt"); + doTest(fileName); + } + + @TestMetadata("val.kt") + public void testVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/properties/val.kt"); + doTest(fileName); + } + + @TestMetadata("var.kt") + public void testVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/properties/var.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/sam") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Sam extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSam() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("enhancedSamConstructor.kt") + public void testEnhancedSamConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("inheritedStaticSam.kt") + public void testInheritedStaticSam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/inheritedStaticSam.kt"); + doTest(fileName); + } + + @TestMetadata("privateCandidatesWithWrongArguments.kt") + public void testPrivateCandidatesWithWrongArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt"); + doTest(fileName); + } + + @TestMetadata("samOnTypeParameter.kt") + public void testSamOnTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/samOnTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("staticSamFromImportWithStar.kt") + public void testStaticSamFromImportWithStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.kt"); + doTest(fileName); + } + + @TestMetadata("staticSamWithExplicitImport.kt") + public void testStaticSamWithExplicitImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.kt"); + doTest(fileName); + } + + @TestMetadata("typeInferenceOnSamAdapters.kt") + public void testTypeInferenceOnSamAdapters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/sam/typeInferenceOnSamAdapters.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SamByProjectedType extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSamByProjectedType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("genericInReturnType.kt") + public void testGenericInReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("genericInValueParameter.kt") + public void testGenericInValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("genericSuperWildcard.kt") + public void testGenericSuperWildcard() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericSuperWildcard.kt"); + doTest(fileName); + } + + @TestMetadata("noAdapterBecuaseOfRecursiveUpperBound.kt") + public void testNoAdapterBecuaseOfRecursiveUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("starProjectionComplexUpperBound.kt") + public void testStarProjectionComplexUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType/starProjectionComplexUpperBound.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/j+k/types") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Types extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/arrayList.kt"); + doTest(fileName); + } + + @TestMetadata("returnCollection.kt") + public void testReturnCollection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt"); + doTest(fileName); + } + + @TestMetadata("shapeMismatchInCovariantPosition.kt") + public void testShapeMismatchInCovariantPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt"); + doTest(fileName); + } + + @TestMetadata("shapeMismatchInCovariantPositionGeneric.kt") + public void testShapeMismatchInCovariantPositionGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/java8Overrides") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Java8Overrides extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("abstractBaseClassMemberNotImplemented.kt") + public void testAbstractBaseClassMemberNotImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/abstractBaseClassMemberNotImplemented.kt"); + doTest(fileName); + } + + @TestMetadata("abstractVsAbstract.kt") + public void testAbstractVsAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/abstractVsAbstract.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInJava8Overrides() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("defaultVsAbstract.kt") + public void testDefaultVsAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/defaultVsAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("hidingMethodOfAny.kt") + public void testHidingMethodOfAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/hidingMethodOfAny.kt"); + doTest(fileName); + } + + @TestMetadata("implementingMethodOfAny.kt") + public void testImplementingMethodOfAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/implementingMethodOfAny.kt"); + doTest(fileName); + } + + @TestMetadata("notAMethodOfAny.kt") + public void testNotAMethodOfAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/notAMethodOfAny.kt"); + doTest(fileName); + } + + @TestMetadata("overridingMethodOfAnyChain.kt") + public void testOverridingMethodOfAnyChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/overridingMethodOfAnyChain.kt"); + doTest(fileName); + } + + @TestMetadata("overridingMethodOfAnyDiamond.kt") + public void testOverridingMethodOfAnyDiamond() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/overridingMethodOfAnyDiamond.kt"); + doTest(fileName); + } + + @TestMetadata("singleRelevantDefault.kt") + public void testSingleRelevantDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/java8Overrides/singleRelevantDefault.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/labels") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Labels extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInLabels() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("automaticLabelFromInfixOperator.kt") + public void testAutomaticLabelFromInfixOperator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/automaticLabelFromInfixOperator.kt"); + doTest(fileName); + } + + @TestMetadata("kt1703.kt") + public void testKt1703() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt1703.kt"); + doTest(fileName); + } + + @TestMetadata("kt361.kt") + public void testKt361() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt361.kt"); + doTest(fileName); + } + + @TestMetadata("kt3920.kt") + public void testKt3920() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt3920.kt"); + doTest(fileName); + } + + @TestMetadata("kt3988.kt") + public void testKt3988() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt3988.kt"); + doTest(fileName); + } + + @TestMetadata("kt4247.kt") + public void testKt4247() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt4247.kt"); + doTest(fileName); + } + + @TestMetadata("kt4586.kt") + public void testKt4586() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt4586.kt"); + doTest(fileName); + } + + @TestMetadata("kt4603.kt") + public void testKt4603() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt4603.kt"); + doTest(fileName); + } + + @TestMetadata("kt591.kt") + public void testKt591() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/kt591.kt"); + doTest(fileName); + } + + @TestMetadata("labelReferencesInsideObjectExpressions.kt") + public void testLabelReferencesInsideObjectExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/labelReferencesInsideObjectExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("labeledFunctionLiteral.kt") + public void testLabeledFunctionLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/labeledFunctionLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("labelsMustBeNamed.kt") + public void testLabelsMustBeNamed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/labels/labelsMustBeNamed.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/lateinit") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Lateinit extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInLateinit() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("modifierApplicability.kt") + public void testModifierApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/lateinit/modifierApplicability.kt"); + doTest(fileName); + } + + @TestMetadata("setter.kt") + public void testSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/lateinit/setter.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/library") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Library extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInLibrary() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Collections.kt") + public void testCollections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/library/Collections.kt"); + doTest(fileName); + } + + @TestMetadata("kt828.kt") + public void testKt828() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/library/kt828.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/modifiers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Modifiers extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInModifiers() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/annotations.kt"); + doTest(fileName); + } + + @TestMetadata("defaultModifier.kt") + public void testDefaultModifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt"); + doTest(fileName); + } + + @TestMetadata("IllegalModifiers.kt") + public void testIllegalModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("incompatibleVarianceModifiers.kt") + public void testIncompatibleVarianceModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("inlineParameters.kt") + public void testInlineParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/inlineParameters.kt"); + doTest(fileName); + } + + @TestMetadata("internalInInterface.kt") + public void testInternalInInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/internalInInterface.kt"); + doTest(fileName); + } + + @TestMetadata("modifierOnParameterInFunctionType.kt") + public void testModifierOnParameterInFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/modifierOnParameterInFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("NoLocalVisibility.kt") + public void testNoLocalVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("openInInterface.kt") + public void testOpenInInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/openInInterface.kt"); + doTest(fileName); + } + + @TestMetadata("primaryConstructorMissingBrackets.kt") + public void testPrimaryConstructorMissingBrackets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("primaryConstructorMissingKeyword.kt") + public void testPrimaryConstructorMissingKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("privateInInterface.kt") + public void testPrivateInInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/privateInInterface.kt"); + doTest(fileName); + } + + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/protected.kt"); + doTest(fileName); + } + + @TestMetadata("redundantTargets.kt") + public void testRedundantTargets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/redundantTargets.kt"); + doTest(fileName); + } + + @TestMetadata("repeatedModifiers.kt") + public void testRepeatedModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/modifiers/const") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Const extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInConst() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("applicability.kt") + public void testApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/applicability.kt"); + doTest(fileName); + } + + @TestMetadata("arrayInAnnotationArgumentType.kt") + public void testArrayInAnnotationArgumentType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt"); + doTest(fileName); + } + + @TestMetadata("constInteraction.kt") + public void testConstInteraction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/constInteraction.kt"); + doTest(fileName); + } + + @TestMetadata("fromJava.kt") + public void testFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt"); + doTest(fileName); + } + + @TestMetadata("fromJavaSubclass.kt") + public void testFromJavaSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/fromJavaSubclass.kt"); + doTest(fileName); + } + + @TestMetadata("kt12248.kt") + public void testKt12248() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/kt12248.kt"); + doTest(fileName); + } + + @TestMetadata("kt15913.kt") + public void testKt15913() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/kt15913.kt"); + doTest(fileName); + } + + @TestMetadata("noDivisionByZeroFeature.kt") + public void testNoDivisionByZeroFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/noDivisionByZeroFeature.kt"); + doTest(fileName); + } + + @TestMetadata("types.kt") + public void testTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/const/types.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/modifiers/operatorInfix") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OperatorInfix extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOperatorInfix() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("LocalFunctions.kt") + public void testLocalFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("MemberFunctions.kt") + public void testMemberFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multimodule") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Multimodule extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInMultimodule() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/internal.kt"); + doTest(fileName); + } + + @TestMetadata("kt14249.kt") + public void testKt14249() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/kt14249.kt"); + doTest(fileName); + } + + @TestMetadata("packagePrivate.kt") + public void testPackagePrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt"); + doTest(fileName); + } + + @TestMetadata("publishedApiInternal.kt") + public void testPublishedApiInternal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt"); + doTest(fileName); + } + + @TestMetadata("redundantElseInWhen.kt") + public void testRedundantElseInWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.kt"); + doTest(fileName); + } + + @TestMetadata("varargConflict.kt") + public void testVarargConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/varargConflict.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DuplicateClass extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDuplicateClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("collectionMethodStub.kt") + public void testCollectionMethodStub() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt"); + doTest(fileName); + } + + @TestMetadata("differentGenericArguments.kt") + public void testDifferentGenericArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.kt"); + doTest(fileName); + } + + @TestMetadata("differentGenericArgumentsReversed.kt") + public void testDifferentGenericArgumentsReversed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.kt"); + doTest(fileName); + } + + @TestMetadata("duplicateClass.kt") + public void testDuplicateClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.kt"); + doTest(fileName); + } + + @TestMetadata("duplicateNestedClasses.kt") + public void testDuplicateNestedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("duplicateSuperClass.kt") + public void testDuplicateSuperClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.kt"); + doTest(fileName); + } + + @TestMetadata("genericArgumentNumberMismatch.kt") + public void testGenericArgumentNumberMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("genericSuperClass.kt") + public void testGenericSuperClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.kt"); + doTest(fileName); + } + + @TestMetadata("inTheSameModuleWithUsage.kt") + public void testInTheSameModuleWithUsage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.kt"); + doTest(fileName); + } + + @TestMetadata("inTheSameModuleWithUsageNoTypeAnnotation.kt") + public void testInTheSameModuleWithUsageNoTypeAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("members.kt") + public void testMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.kt"); + doTest(fileName); + } + + @TestMetadata("sameClassNameDifferentPackages.kt") + public void testSameClassNameDifferentPackages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt"); + doTest(fileName); + } + + @TestMetadata("sameGenericArguments.kt") + public void testSameGenericArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DuplicateMethod extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDuplicateMethod() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classGenericsInParams.kt") + public void testClassGenericsInParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.kt"); + doTest(fileName); + } + + @TestMetadata("classGenericsInParamsBoundMismatch.kt") + public void testClassGenericsInParamsBoundMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("classGenericsInParamsIndexMismatch.kt") + public void testClassGenericsInParamsIndexMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("classGenericsInParamsNameMismatch.kt") + public void testClassGenericsInParamsNameMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("classGenericsInReturnType.kt") + public void testClassGenericsInReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("classVsFunctionGenericsInParamsMismatch.kt") + public void testClassVsFunctionGenericsInParamsMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("covariantReturnTypes.kt") + public void testCovariantReturnTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.kt"); + doTest(fileName); + } + + @TestMetadata("differenceInParamNames.kt") + public void testDifferenceInParamNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.kt"); + doTest(fileName); + } + + @TestMetadata("differentGenericsInParams.kt") + public void testDifferentGenericsInParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.kt"); + doTest(fileName); + } + + @TestMetadata("differentNumberOfParams.kt") + public void testDifferentNumberOfParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.kt"); + doTest(fileName); + } + + @TestMetadata("differentReturnTypes.kt") + public void testDifferentReturnTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.kt"); + doTest(fileName); + } + + @TestMetadata("extensionMatch.kt") + public void testExtensionMatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.kt"); + doTest(fileName); + } + + @TestMetadata("functionGenericsInParams.kt") + public void testFunctionGenericsInParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.kt"); + doTest(fileName); + } + + @TestMetadata("functionGenericsInParamsBoundsMismatch.kt") + public void testFunctionGenericsInParamsBoundsMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("functionGenericsInParamsEqNull.kt") + public void testFunctionGenericsInParamsEqNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.kt"); + doTest(fileName); + } + + @TestMetadata("functionGenericsInParamsNotIs.kt") + public void testFunctionGenericsInParamsNotIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.kt"); + doTest(fileName); + } + + @TestMetadata("functionGenericsInParamsReturnFooT.kt") + public void testFunctionGenericsInParamsReturnFooT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.kt"); + doTest(fileName); + } + + @TestMetadata("functionGenericsInParamsReturnT.kt") + public void testFunctionGenericsInParamsReturnT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteCodeNoNoneApplicable.kt") + public void testIncompleteCodeNoNoneApplicable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.kt"); + doTest(fileName); + } + + @TestMetadata("noGenericsInParams.kt") + public void testNoGenericsInParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.kt"); + doTest(fileName); + } + + @TestMetadata("noParams.kt") + public void testNoParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.kt"); + doTest(fileName); + } + + @TestMetadata("sameGenericsInParams.kt") + public void testSameGenericsInParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.kt"); + doTest(fileName); + } + + @TestMetadata("simpleWithInheritance.kt") + public void testSimpleWithInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("sinceKotlin.kt") + public void testSinceKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("substitutedGenericInParams.kt") + public void testSubstitutedGenericInParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DuplicateSuper extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDuplicateSuper() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("differentSuperTraits.kt") + public void testDifferentSuperTraits() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.kt"); + doTest(fileName); + } + + @TestMetadata("sameSuperTrait.kt") + public void testSameSuperTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.kt"); + doTest(fileName); + } + + @TestMetadata("sameSuperTraitDifferentBounds.kt") + public void testSameSuperTraitDifferentBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.kt"); + doTest(fileName); + } + + @TestMetadata("sameSuperTraitGenerics.kt") + public void testSameSuperTraitGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class HiddenClass extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInHiddenClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("deprecatedHiddenImportPriority.kt") + public void testDeprecatedHiddenImportPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedHiddenMultipleClasses.kt") + public void testDeprecatedHiddenMultipleClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.kt"); + doTest(fileName); + } + + @TestMetadata("sinceKotlinImportPriority.kt") + public void testSinceKotlinImportPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.kt"); + doTest(fileName); + } + + @TestMetadata("sinceKotlinMultipleClasses.kt") + public void testSinceKotlinMultipleClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Multiplatform extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInMultiplatform() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("implDelegatedMember.kt") + public void testImplDelegatedMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/implDelegatedMember.kt"); + doTest(fileName); + } + + @TestMetadata("implDynamic.kt") + public void testImplDynamic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/implDynamic.kt"); + doTest(fileName); + } + + @TestMetadata("implFakeOverride.kt") + public void testImplFakeOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/implFakeOverride.kt"); + doTest(fileName); + } + + @TestMetadata("modifierApplicability.kt") + public void testModifierApplicability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt"); + doTest(fileName); + } + + @TestMetadata("namedArguments.kt") + public void testNamedArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/namedArguments.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("additionalEntriesInImpl.kt") + public void testAdditionalEntriesInImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/enum/additionalEntriesInImpl.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInEnum() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("constructorInHeaderEnum.kt") + public void testConstructorInHeaderEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt"); + doTest(fileName); + } + + @TestMetadata("differentEntryOrder.kt") + public void testDifferentEntryOrder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/enum/differentEntryOrder.kt"); + doTest(fileName); + } + + @TestMetadata("enumEntryWithBody.kt") + public void testEnumEntryWithBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/enum/enumEntryWithBody.kt"); + doTest(fileName); + } + + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/enum/simpleEnum.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/generic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Generic extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInGeneric() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/generic"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("membersInGenericClass.kt") + public void testMembersInGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/generic/membersInGenericClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class HeaderClass extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInHeaderClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/headerClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classKinds.kt") + public void testClassKinds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/classKinds.kt"); + doTest(fileName); + } + + @TestMetadata("explicitConstructorDelegation.kt") + public void testExplicitConstructorDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/explicitConstructorDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("genericClassImplTypeAlias.kt") + public void testGenericClassImplTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("headerClassMember.kt") + public void testHeaderClassMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassMember.kt"); + doTest(fileName); + } + + @TestMetadata("headerClassWithFunctionBody.kt") + public void testHeaderClassWithFunctionBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt"); + doTest(fileName); + } + + @TestMetadata("implDataClass.kt") + public void testImplDataClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/implDataClass.kt"); + doTest(fileName); + } + + @TestMetadata("implOpenClass.kt") + public void testImplOpenClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/implOpenClass.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClasses.kt") + public void testNestedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("simpleHeaderClass.kt") + public void testSimpleHeaderClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/simpleHeaderClass.kt"); + doTest(fileName); + } + + @TestMetadata("superClass.kt") + public void testSuperClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/java") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Java extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/java"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("flexibleTypes.kt") + public void testFlexibleTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/java/flexibleTypes.kt"); + doTest(fileName); + } + + @TestMetadata("parameterNames.kt") + public void testParameterNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/java/parameterNames.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelFun extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTopLevelFun() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelFun"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callHeaderFun.kt") + public void testCallHeaderFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callHeaderFun.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingHeaderDeclarations.kt") + public void testConflictingHeaderDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingHeaderDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingImplDeclarations.kt") + public void testConflictingImplDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("defaultArguments.kt") + public void testDefaultArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/defaultArguments.kt"); + doTest(fileName); + } + + @TestMetadata("functionModifiers.kt") + public void testFunctionModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/functionModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("headerAndImplInDIfferentPackages.kt") + public void testHeaderAndImplInDIfferentPackages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt"); + doTest(fileName); + } + + @TestMetadata("headerDeclarationWithBody.kt") + public void testHeaderDeclarationWithBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerDeclarationWithBody.kt"); + doTest(fileName); + } + + @TestMetadata("headerWithoutImpl.kt") + public void testHeaderWithoutImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerWithoutImpl.kt"); + doTest(fileName); + } + + @TestMetadata("implDeclarationWithoutBody.kt") + public void testImplDeclarationWithoutBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.kt"); + doTest(fileName); + } + + @TestMetadata("implWithoutHeader.kt") + public void testImplWithoutHeader() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implWithoutHeader.kt"); + doTest(fileName); + } + + @TestMetadata("inlineFun.kt") + public void testInlineFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt"); + doTest(fileName); + } + + @TestMetadata("simpleHeaderFun.kt") + public void testSimpleHeaderFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simpleHeaderFun.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TopLevelProperty extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTopLevelProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("differentKindsOfProperties.kt") + public void testDifferentKindsOfProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt"); + doTest(fileName); + } + + @TestMetadata("simpleHeaderVar.kt") + public void testSimpleHeaderVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simpleHeaderVar.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/namedArguments") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NamedArguments extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNamedArguments() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("allowForJavaAnnotation.kt") + public void testAllowForJavaAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("ambiguousNamedArguments1.kt") + public void testAmbiguousNamedArguments1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.kt"); + doTest(fileName); + } + + @TestMetadata("ambiguousNamedArguments2.kt") + public void testAmbiguousNamedArguments2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.kt"); + doTest(fileName); + } + + @TestMetadata("ambiguousNamedArgumentsWithGenerics1.kt") + public void testAmbiguousNamedArgumentsWithGenerics1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.kt"); + doTest(fileName); + } + + @TestMetadata("ambiguousNamedArgumentsWithGenerics2.kt") + public void testAmbiguousNamedArgumentsWithGenerics2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.kt"); + doTest(fileName); + } + + @TestMetadata("ambiguousNamedArgumentsWithGenerics3.kt") + public void testAmbiguousNamedArgumentsWithGenerics3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.kt"); + doTest(fileName); + } + + @TestMetadata("disallowForJavaConstructor.kt") + public void testDisallowForJavaConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("disallowForJavaMethods.kt") + public void testDisallowForJavaMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.kt"); + doTest(fileName); + } + + @TestMetadata("disallowForSamAdapterConstructor.kt") + public void testDisallowForSamAdapterConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("disallowForSamAdapterFunction.kt") + public void testDisallowForSamAdapterFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt"); + doTest(fileName); + } + + @TestMetadata("namedArgumentsAndDefaultValues.kt") + public void testNamedArgumentsAndDefaultValues() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.kt"); + doTest(fileName); + } + + @TestMetadata("namedArgumentsInOverloads.kt") + public void testNamedArgumentsInOverloads() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverloads.kt"); + doTest(fileName); + } + + @TestMetadata("namedArgumentsInOverrides.kt") + public void testNamedArgumentsInOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NullabilityAndSmartCasts extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNullabilityAndSmartCasts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AssertNotNull.kt") + public void testAssertNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("dataFlowInfoAfterExclExcl.kt") + public void testDataFlowInfoAfterExclExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/dataFlowInfoAfterExclExcl.kt"); + doTest(fileName); + } + + @TestMetadata("equalityUnderNotNullCheck.kt") + public void testEqualityUnderNotNullCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/equalityUnderNotNullCheck.kt"); + doTest(fileName); + } + + @TestMetadata("funcLiteralArgsInsideAmbiguity.kt") + public void testFuncLiteralArgsInsideAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("funcLiteralArgsInsideUnresolvedFunction.kt") + public void testFuncLiteralArgsInsideUnresolvedFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideUnresolvedFunction.kt"); + doTest(fileName); + } + + @TestMetadata("InfixCallNullability.kt") + public void testInfixCallNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/InfixCallNullability.kt"); + doTest(fileName); + } + + @TestMetadata("kt1270.kt") + public void testKt1270() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt"); + doTest(fileName); + } + + @TestMetadata("kt1680.kt") + public void testKt1680() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1680.kt"); + doTest(fileName); + } + + @TestMetadata("kt1778.kt") + public void testKt1778() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1778.kt"); + doTest(fileName); + } + + @TestMetadata("kt2109.kt") + public void testKt2109() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2109.kt"); + doTest(fileName); + } + + @TestMetadata("kt2125.kt") + public void testKt2125() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2125.kt"); + doTest(fileName); + } + + @TestMetadata("kt2146.kt") + public void testKt2146() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt"); + doTest(fileName); + } + + @TestMetadata("kt2164.kt") + public void testKt2164() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt"); + doTest(fileName); + } + + @TestMetadata("kt2176.kt") + public void testKt2176() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2176.kt"); + doTest(fileName); + } + + @TestMetadata("kt2195.kt") + public void testKt2195() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2195.kt"); + doTest(fileName); + } + + @TestMetadata("kt2212.kt") + public void testKt2212() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2212.kt"); + doTest(fileName); + } + + @TestMetadata("kt2216.kt") + public void testKt2216() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt"); + doTest(fileName); + } + + @TestMetadata("kt2223.kt") + public void testKt2223() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2223.kt"); + doTest(fileName); + } + + @TestMetadata("kt2234.kt") + public void testKt2234() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2234.kt"); + doTest(fileName); + } + + @TestMetadata("kt2336.kt") + public void testKt2336() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2336.kt"); + doTest(fileName); + } + + @TestMetadata("kt244.kt") + public void testKt244() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt"); + doTest(fileName); + } + + @TestMetadata("kt362.kt") + public void testKt362() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt362.kt"); + doTest(fileName); + } + + @TestMetadata("noSenselessNullOnNullableType.kt") + public void testNoSenselessNullOnNullableType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/noSenselessNullOnNullableType.kt"); + doTest(fileName); + } + + @TestMetadata("noUnnecessaryNotNullAssertionOnErrorType.kt") + public void testNoUnnecessaryNotNullAssertionOnErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/noUnnecessaryNotNullAssertionOnErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("NullableNothingIsExactlyNull.kt") + public void testNullableNothingIsExactlyNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/NullableNothingIsExactlyNull.kt"); + doTest(fileName); + } + + @TestMetadata("nullableReceiverWithOverloadedMethod.kt") + public void testNullableReceiverWithOverloadedMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt"); + doTest(fileName); + } + + @TestMetadata("PreferExtensionsOnNullableReceiver.kt") + public void testPreferExtensionsOnNullableReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/PreferExtensionsOnNullableReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("QualifiedExpressionNullability.kt") + public void testQualifiedExpressionNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt"); + doTest(fileName); + } + + @TestMetadata("ReceiverNullability.kt") + public void testReceiverNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/ReceiverNullability.kt"); + doTest(fileName); + } + + @TestMetadata("SenselessNullInWhen.kt") + public void testSenselessNullInWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/SenselessNullInWhen.kt"); + doTest(fileName); + } + + @TestMetadata("senslessComparisonWithNullOnTypeParameters.kt") + public void testSenslessComparisonWithNullOnTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/senslessComparisonWithNullOnTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastReceiverWithGenerics.kt") + public void testSmartCastReceiverWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/smartCastReceiverWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastsAndBooleanExpressions.kt") + public void testSmartCastsAndBooleanExpressions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/smartCastsAndBooleanExpressions.kt"); + doTest(fileName); + } + + @TestMetadata("unnecessaryNotNullAssertion.kt") + public void testUnnecessaryNotNullAssertion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt"); + doTest(fileName); + } + + @TestMetadata("unstableSmartcastWhenOpenGetterWithOverloading.kt") + public void testUnstableSmartcastWhenOpenGetterWithOverloading() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWhenOpenGetterWithOverloading.kt"); + doTest(fileName); + } + + @TestMetadata("unstableSmartcastWithOverloadedExtensions.kt") + public void testUnstableSmartcastWithOverloadedExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/nullableTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NullableTypes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNullableTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("baseWithNullableUpperBound.kt") + public void testBaseWithNullableUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/baseWithNullableUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("elvisOnUnit.kt") + public void testElvisOnUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/elvisOnUnit.kt"); + doTest(fileName); + } + + @TestMetadata("nullAssertOnTypeWithNullableUpperBound.kt") + public void testNullAssertOnTypeWithNullableUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/nullAssertOnTypeWithNullableUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("nullableArgumentForIn.kt") + public void testNullableArgumentForIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.kt"); + doTest(fileName); + } + + @TestMetadata("nullableArgumentToNonNullParameterPlatform.kt") + public void testNullableArgumentToNonNullParameterPlatform() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt"); + doTest(fileName); + } + + @TestMetadata("nullableArgumentToNonNullParameterSimple.kt") + public void testNullableArgumentToNonNullParameterSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt"); + doTest(fileName); + } + + @TestMetadata("redundantNullable.kt") + public void testRedundantNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/redundantNullable.kt"); + doTest(fileName); + } + + @TestMetadata("redundantNullableInSupertype.kt") + public void testRedundantNullableInSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/redundantNullableInSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("safeAccessOnUnit.kt") + public void testSafeAccessOnUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.kt"); + doTest(fileName); + } + + @TestMetadata("safeCallOnTypeWithNullableUpperBound.kt") + public void testSafeCallOnTypeWithNullableUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("safeCallWithInvoke.kt") + public void testSafeCallWithInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("uselessElvis.kt") + public void testUselessElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/numbers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Numbers extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNumbers() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("characterIsNotANumber.kt") + public void testCharacterIsNotANumber() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt"); + doTest(fileName); + } + + @TestMetadata("doublesInSimpleConstraints.kt") + public void testDoublesInSimpleConstraints() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt"); + doTest(fileName); + } + + @TestMetadata("intValuesOutOfRange.kt") + public void testIntValuesOutOfRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt"); + doTest(fileName); + } + + @TestMetadata("numbersInSimpleConstraints.kt") + public void testNumbersInSimpleConstraints() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/objects") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Objects extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInObjects() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("invokeOnInnerObject.kt") + public void testInvokeOnInnerObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.kt"); + doTest(fileName); + } + + @TestMetadata("kt2240.kt") + public void testKt2240() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt2240.kt"); + doTest(fileName); + } + + @TestMetadata("kt5527.kt") + public void testKt5527() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt5527.kt"); + doTest(fileName); + } + + @TestMetadata("localObjectInsideObject.kt") + public void testLocalObjectInsideObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/localObjectInsideObject.kt"); + doTest(fileName); + } + + @TestMetadata("localObjects.kt") + public void testLocalObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/localObjects.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassInAnonymousObject.kt") + public void testNestedClassInAnonymousObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/nestedClassInAnonymousObject.kt"); + doTest(fileName); + } + + @TestMetadata("objectInsideFun.kt") + public void testObjectInsideFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/objectInsideFun.kt"); + doTest(fileName); + } + + @TestMetadata("objectLiteralExpressionTypeMismatch.kt") + public void testObjectLiteralExpressionTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/objectLiteralExpressionTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("Objects.kt") + public void testObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/Objects.kt"); + doTest(fileName); + } + + @TestMetadata("ObjectsInheritance.kt") + public void testObjectsInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/ObjectsInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("ObjectsLocal.kt") + public void testObjectsLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/ObjectsLocal.kt"); + doTest(fileName); + } + + @TestMetadata("ObjectsNested.kt") + public void testObjectsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/ObjectsNested.kt"); + doTest(fileName); + } + + @TestMetadata("OpenInObject.kt") + public void testOpenInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/OpenInObject.kt"); + doTest(fileName); + } + + @TestMetadata("upperBoundViolated.kt") + public void testUpperBoundViolated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/upperBoundViolated.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/operatorRem") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OperatorRem extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOperatorRem() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DeprecatedModAssignOperatorConventions.kt") + public void testDeprecatedModAssignOperatorConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/DeprecatedModAssignOperatorConventions.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedModConvention.kt") + public void testDeprecatedModConvention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt"); + doTest(fileName); + } + + @TestMetadata("DeprecatedModOperatorConventions.kt") + public void testDeprecatedModOperatorConventions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/DeprecatedModOperatorConventions.kt"); + doTest(fileName); + } + + @TestMetadata("doNotResolveToInapplicableRem.kt") + public void testDoNotResolveToInapplicableRem() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/doNotResolveToInapplicableRem.kt"); + doTest(fileName); + } + + @TestMetadata("modWithRemAssign.kt") + public void testModWithRemAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/modWithRemAssign.kt"); + doTest(fileName); + } + + @TestMetadata("noDeprecatedModConventionWithoutFeature.kt") + public void testNoDeprecatedModConventionWithoutFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.kt"); + doTest(fileName); + } + + @TestMetadata("noOperatorRemFeature.kt") + public void testNoOperatorRemFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/noOperatorRemFeature.kt"); + doTest(fileName); + } + + @TestMetadata("noWarningForModFromBuiltinsWhenApi1_0.kt") + public void testNoWarningForModFromBuiltinsWhenApi1_0() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0.kt"); + doTest(fileName); + } + + @TestMetadata("numberRemConversions.kt") + public void testNumberRemConversions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt"); + doTest(fileName); + } + + @TestMetadata("operatorRem.kt") + public void testOperatorRem() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/operatorRem.kt"); + doTest(fileName); + } + + @TestMetadata("preferRemAsExtentionOverMod.kt") + public void testPreferRemAsExtentionOverMod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/preferRemAsExtentionOverMod.kt"); + doTest(fileName); + } + + @TestMetadata("preferRemAsMemberOverMod.kt") + public void testPreferRemAsMemberOverMod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/preferRemAsMemberOverMod.kt"); + doTest(fileName); + } + + @TestMetadata("preferRemFromCompanionObjectOverRem.kt") + public void testPreferRemFromCompanionObjectOverRem() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/preferRemFromCompanionObjectOverRem.kt"); + doTest(fileName); + } + + @TestMetadata("preferRemOverModInLocalFunctions.kt") + public void testPreferRemOverModInLocalFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/preferRemOverModInLocalFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("preferRemWithImplicitReceivers.kt") + public void testPreferRemWithImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("prefereRemAsExtensionOverMemberMod.kt") + public void testPrefereRemAsExtensionOverMemberMod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/prefereRemAsExtensionOverMemberMod.kt"); + doTest(fileName); + } + + @TestMetadata("remAndRemAssignAmbiguity.kt") + public void testRemAndRemAssignAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/remAndRemAssignAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("remWithModAndModAssign.kt") + public void testRemWithModAndModAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/remWithModAndModAssign.kt"); + doTest(fileName); + } + + @TestMetadata("remWithModAssign.kt") + public void testRemWithModAssign() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/remWithModAssign.kt"); + doTest(fileName); + } + + @TestMetadata("resolveModIfRemIsHidden.kt") + public void testResolveModIfRemIsHidden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.kt"); + doTest(fileName); + } + + @TestMetadata("resolveToModWhenNoOperatorRemFeature.kt") + public void testResolveToModWhenNoOperatorRemFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/operatorsOverloading") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OperatorsOverloading extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOperatorsOverloading() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AssignOperatorAmbiguity.kt") + public void testAssignOperatorAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("AssignmentOperations.kt") + public void testAssignmentOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/AssignmentOperations.kt"); + doTest(fileName); + } + + @TestMetadata("assignmentOperationsCheckReturnType.kt") + public void testAssignmentOperationsCheckReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("compareToNullable.kt") + public void testCompareToNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/compareToNullable.kt"); + doTest(fileName); + } + + @TestMetadata("InconsistentGetSet.kt") + public void testInconsistentGetSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.kt"); + doTest(fileName); + } + + @TestMetadata("IteratorAmbiguity.kt") + public void testIteratorAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("kt1028.kt") + public void testKt1028() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/kt1028.kt"); + doTest(fileName); + } + + @TestMetadata("kt11300.kt") + public void testKt11300() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt"); + doTest(fileName); + } + + @TestMetadata("kt13330.kt") + public void testKt13330() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt"); + doTest(fileName); + } + + @TestMetadata("kt13349.kt") + public void testKt13349() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/kt13349.kt"); + doTest(fileName); + } + + @TestMetadata("kt3450.kt") + public void testKt3450() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.kt"); + doTest(fileName); + } + + @TestMetadata("plusAssignOnArray.kt") + public void testPlusAssignOnArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnArray.kt"); + doTest(fileName); + } + + @TestMetadata("plusAssignOnLocal.kt") + public void testPlusAssignOnLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnLocal.kt"); + doTest(fileName); + } + + @TestMetadata("plusAssignOnProperty.kt") + public void testPlusAssignOnProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnProperty.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/overload") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Overload extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOverload() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ConflictingOlverloadsGenericFunctions.kt") + public void testConflictingOlverloadsGenericFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOlverloadsGenericFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsFunsDifferentReturnInClass.kt") + public void testConflictingOverloadsFunsDifferentReturnInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsFunsDifferentReturnInPackage.kt") + public void testConflictingOverloadsFunsDifferentReturnInPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInPackage.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsIdenticalExtFunsInPackage.kt") + public void testConflictingOverloadsIdenticalExtFunsInPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalExtFunsInPackage.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsIdenticalFunsInClass.kt") + public void testConflictingOverloadsIdenticalFunsInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsIdenticalFunsTPInClass.kt") + public void testConflictingOverloadsIdenticalFunsTPInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsTPInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsIdenticalValsInClass.kt") + public void testConflictingOverloadsIdenticalValsInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalValsInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingOverloadsValsDifferentTypeInClass.kt") + public void testConflictingOverloadsValsDifferentTypeInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsValsDifferentTypeInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorVsFunOverload.kt") + public void testConstructorVsFunOverload() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ConstructorVsFunOverload.kt"); + doTest(fileName); + } + + @TestMetadata("defaultParameters.kt") + public void testDefaultParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/defaultParameters.kt"); + doTest(fileName); + } + + @TestMetadata("EmptyArgumentListInLambda.kt") + public void testEmptyArgumentListInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/EmptyArgumentListInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("ExtFunDifferentReceiver.kt") + public void testExtFunDifferentReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/ExtFunDifferentReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("FunNoConflictInDifferentPackages.kt") + public void testFunNoConflictInDifferentPackages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/FunNoConflictInDifferentPackages.kt"); + doTest(fileName); + } + + @TestMetadata("kt10939.kt") + public void testKt10939() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/kt10939.kt"); + doTest(fileName); + } + + @TestMetadata("kt1998.kt") + public void testKt1998() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/kt1998.kt"); + doTest(fileName); + } + + @TestMetadata("kt2493.kt") + public void testKt2493() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/kt2493.kt"); + doTest(fileName); + } + + @TestMetadata("kt7068.kt") + public void testKt7068() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/kt7068.kt"); + doTest(fileName); + } + + @TestMetadata("kt7068_2.kt") + public void testKt7068_2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/kt7068_2.kt"); + doTest(fileName); + } + + @TestMetadata("kt7440.kt") + public void testKt7440() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/kt7440.kt"); + doTest(fileName); + } + + @TestMetadata("LocalFunctions.kt") + public void testLocalFunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/LocalFunctions.kt"); + doTest(fileName); + } + + @TestMetadata("onlyPrivateOverloadsDiagnostic.kt") + public void testOnlyPrivateOverloadsDiagnostic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/onlyPrivateOverloadsDiagnostic.kt"); + doTest(fileName); + } + + @TestMetadata("OverloadFunRegularAndExt.kt") + public void testOverloadFunRegularAndExt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/OverloadFunRegularAndExt.kt"); + doTest(fileName); + } + + @TestMetadata("OverloadVarAndFunInClass.kt") + public void testOverloadVarAndFunInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/OverloadVarAndFunInClass.kt"); + doTest(fileName); + } + + @TestMetadata("SyntheticAndNotSynthetic.kt") + public void testSyntheticAndNotSynthetic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/SyntheticAndNotSynthetic.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParameterMultipleBounds.kt") + public void testTypeParameterMultipleBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/TypeParameterMultipleBounds.kt"); + doTest(fileName); + } + + @TestMetadata("UnsubstitutedJavaGenetics.kt") + public void testUnsubstitutedJavaGenetics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/overload/UnsubstitutedJavaGenetics.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/override") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Override extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("AbstractFunImplemented.kt") + public void testAbstractFunImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AbstractFunImplemented.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractFunNotImplemented.kt") + public void testAbstractFunNotImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractValImplemented.kt") + public void testAbstractValImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AbstractValImplemented.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractValNotImplemented.kt") + public void testAbstractValNotImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractVarImplemented.kt") + public void testAbstractVarImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AbstractVarImplemented.kt"); + doTest(fileName); + } + + @TestMetadata("AbstractVarNotImplemented.kt") + public void testAbstractVarNotImplemented() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInOverride() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AllPrivateFromSuperTypes.kt") + public void testAllPrivateFromSuperTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt"); + doTest(fileName); + } + + @TestMetadata("ComplexValRedeclaration.kt") + public void testComplexValRedeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ComplexValRedeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingFunctionSignatureFromSuperclass.kt") + public void testConflictingFunctionSignatureFromSuperclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ConflictingFunctionSignatureFromSuperclass.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingPropertySignatureFromSuperclass.kt") + public void testConflictingPropertySignatureFromSuperclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ConflictingPropertySignatureFromSuperclass.kt"); + doTest(fileName); + } + + @TestMetadata("DefaultParameterValueInOverride.kt") + public void testDefaultParameterValueInOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/DefaultParameterValueInOverride.kt"); + doTest(fileName); + } + + @TestMetadata("DefaultParameterValues-NoErrorsWhenInheritingFromOneTypeTwice.kt") + public void testDefaultParameterValues_NoErrorsWhenInheritingFromOneTypeTwice() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/DefaultParameterValues-NoErrorsWhenInheritingFromOneTypeTwice.kt"); + doTest(fileName); + } + + @TestMetadata("Delegation.kt") + public void testDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/Delegation.kt"); + doTest(fileName); + } + + @TestMetadata("DelegationFun.kt") + public void testDelegationFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/DelegationFun.kt"); + doTest(fileName); + } + + @TestMetadata("DelegationVal.kt") + public void testDelegationVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/DelegationVal.kt"); + doTest(fileName); + } + + @TestMetadata("DelegationVar.kt") + public void testDelegationVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/DelegationVar.kt"); + doTest(fileName); + } + + @TestMetadata("DuplicateMethod.kt") + public void testDuplicateMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/DuplicateMethod.kt"); + doTest(fileName); + } + + @TestMetadata("EqualityOfIntersectionTypes.kt") + public void testEqualityOfIntersectionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/EqualityOfIntersectionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("ExtendFunctionClass.kt") + public void testExtendFunctionClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt"); + doTest(fileName); + } + + @TestMetadata("FakeOverrideAbstractAndNonAbstractFun.kt") + public void testFakeOverrideAbstractAndNonAbstractFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/FakeOverrideAbstractAndNonAbstractFun.kt"); + doTest(fileName); + } + + @TestMetadata("FakeOverrideDifferentDeclarationSignatures.kt") + public void testFakeOverrideDifferentDeclarationSignatures() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt"); + doTest(fileName); + } + + @TestMetadata("FakeOverrideModality1.kt") + public void testFakeOverrideModality1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/FakeOverrideModality1.kt"); + doTest(fileName); + } + + @TestMetadata("FakeOverrideModality2.kt") + public void testFakeOverrideModality2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/FakeOverrideModality2.kt"); + doTest(fileName); + } + + @TestMetadata("FakeOverrideModality3.kt") + public void testFakeOverrideModality3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/FakeOverrideModality3.kt"); + doTest(fileName); + } + + @TestMetadata("Generics.kt") + public void testGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/Generics.kt"); + doTest(fileName); + } + + @TestMetadata("InvisiblePotentialOverride.kt") + public void testInvisiblePotentialOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/InvisiblePotentialOverride.kt"); + doTest(fileName); + } + + @TestMetadata("kt12358.kt") + public void testKt12358() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt12358.kt"); + doTest(fileName); + } + + @TestMetadata("kt12467.kt") + public void testKt12467() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt12467.kt"); + doTest(fileName); + } + + @TestMetadata("kt12482.kt") + public void testKt12482() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt12482.kt"); + doTest(fileName); + } + + @TestMetadata("kt1862.kt") + public void testKt1862() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt1862.kt"); + doTest(fileName); + } + + @TestMetadata("kt2052.kt") + public void testKt2052() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt2052.kt"); + doTest(fileName); + } + + @TestMetadata("kt2491.kt") + public void testKt2491() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt2491.kt"); + doTest(fileName); + } + + @TestMetadata("kt4763.kt") + public void testKt4763() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt4763.kt"); + doTest(fileName); + } + + @TestMetadata("kt4763property.kt") + public void testKt4763property() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt4763property.kt"); + doTest(fileName); + } + + @TestMetadata("kt4785.kt") + public void testKt4785() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt4785.kt"); + doTest(fileName); + } + + @TestMetadata("kt6014.kt") + public void testKt6014() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt6014.kt"); + doTest(fileName); + } + + @TestMetadata("kt880.kt") + public void testKt880() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt880.kt"); + doTest(fileName); + } + + @TestMetadata("kt8990.kt") + public void testKt8990() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/kt8990.kt"); + doTest(fileName); + } + + @TestMetadata("MissingDelegate.kt") + public void testMissingDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/MissingDelegate.kt"); + doTest(fileName); + } + + @TestMetadata("MultipleDefaultParametersInSupertypes.kt") + public void testMultipleDefaultParametersInSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/MultipleDefaultParametersInSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("MultipleDefaultParametersInSupertypesNoOverride.kt") + public void testMultipleDefaultParametersInSupertypesNoOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/MultipleDefaultParametersInSupertypesNoOverride.kt"); + doTest(fileName); + } + + @TestMetadata("MultipleDefaultsAndNamesInSupertypes.kt") + public void testMultipleDefaultsAndNamesInSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("MultipleDefaultsInSupertypesNoExplicitOverride.kt") + public void testMultipleDefaultsInSupertypesNoExplicitOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt"); + doTest(fileName); + } + + @TestMetadata("NonGenerics.kt") + public void testNonGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/NonGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("ObjectDelegationManyImpl.kt") + public void testObjectDelegationManyImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt"); + doTest(fileName); + } + + @TestMetadata("overrideMemberFromFinalClass.kt") + public void testOverrideMemberFromFinalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/overrideMemberFromFinalClass.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideWithErrors.kt") + public void testOverrideWithErrors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/OverrideWithErrors.kt"); + doTest(fileName); + } + + @TestMetadata("OverridingFinalMember.kt") + public void testOverridingFinalMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/OverridingFinalMember.kt"); + doTest(fileName); + } + + @TestMetadata("ParameterDefaultValues-DefaultValueFromOnlyOneSupertype.kt") + public void testParameterDefaultValues_DefaultValueFromOnlyOneSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ParameterDefaultValues-DefaultValueFromOnlyOneSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("ParentInheritsManyImplementations.kt") + public void testParentInheritsManyImplementations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyInConstructor.kt") + public void testPropertyInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/PropertyInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("ProtectedAndPrivateFromSupertypes.kt") + public void testProtectedAndPrivateFromSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("SuspiciousCase1.kt") + public void testSuspiciousCase1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/SuspiciousCase1.kt"); + doTest(fileName); + } + + @TestMetadata("ToAbstractMembersFromSuper-kt1996.kt") + public void testToAbstractMembersFromSuper_kt1996() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClashesOnInheritance extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInClashesOnInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("covariantOverrides.kt") + public void testCovariantOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleReturnType.kt") + public void testFlexibleReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleReturnTypeIn.kt") + public void testFlexibleReturnTypeIn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeIn.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleReturnTypeList.kt") + public void testFlexibleReturnTypeList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeList.kt"); + doTest(fileName); + } + + @TestMetadata("genericWithUpperBound.kt") + public void testGenericWithUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/genericWithUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("kt13355.kt") + public void testKt13355() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt13355.kt"); + doTest(fileName); + } + + @TestMetadata("kt13355viaJava.kt") + public void testKt13355viaJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt13355viaJava.kt"); + doTest(fileName); + } + + @TestMetadata("kt9550.kt") + public void testKt9550() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt9550.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeMismatch.kt") + public void testReturnTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/returnTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("unrelatedInherited.kt") + public void testUnrelatedInherited() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/unrelatedInherited.kt"); + doTest(fileName); + } + + @TestMetadata("valTypeMismatch.kt") + public void testValTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/valTypeMismatch.kt"); + doTest(fileName); + } + + @TestMetadata("varTypeMismatch.kt") + public void testVarTypeMismatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance/varTypeMismatch.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/override/parameterNames") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ParameterNames extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInParameterNames() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("changeOnOverrideDiagnostic.kt") + public void testChangeOnOverrideDiagnostic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/changeOnOverrideDiagnostic.kt"); + doTest(fileName); + } + + @TestMetadata("differentNamesInSupertypesDiagnostic.kt") + public void testDifferentNamesInSupertypesDiagnostic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt"); + doTest(fileName); + } + + @TestMetadata("invokeInFunctionClass.kt") + public void testInvokeInFunctionClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.kt"); + doTest(fileName); + } + + @TestMetadata("jjkHierarchy.kt") + public void testJjkHierarchy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/jjkHierarchy.kt"); + doTest(fileName); + } + + @TestMetadata("kjkHierarchy.kt") + public void testKjkHierarchy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt"); + doTest(fileName); + } + + @TestMetadata("kjkWithSeveralSupers.kt") + public void testKjkWithSeveralSupers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinInheritsBothJavaAndKotlin.kt") + public void testKotlinInheritsBothJavaAndKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsBothJavaAndKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinInheritsJava.kt") + public void testKotlinInheritsJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsJava.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/override/typeParameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameters extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("classAndTwoInterfaceBounds.kt") + public void testClassAndTwoInterfaceBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/typeParameters/classAndTwoInterfaceBounds.kt"); + doTest(fileName); + } + + @TestMetadata("differentSetsOfBounds.kt") + public void testDifferentSetsOfBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/typeParameters/differentSetsOfBounds.kt"); + doTest(fileName); + } + + @TestMetadata("kt9850.kt") + public void testKt9850() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/typeParameters/kt9850.kt"); + doTest(fileName); + } + + @TestMetadata("simpleVisitorTwoAccepts.kt") + public void testSimpleVisitorTwoAccepts() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/override/typeParameters/simpleVisitorTwoAccepts.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/parenthesizedTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ParenthesizedTypes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInParenthesizedTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationsOnNullableParenthesizedTypes.kt") + public void testAnnotationsOnNullableParenthesizedTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/parenthesizedTypes/annotationsOnNullableParenthesizedTypes.kt"); + doTest(fileName); + } + + @TestMetadata("annotationsOnParenthesizedTypes.kt") + public void testAnnotationsOnParenthesizedTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/parenthesizedTypes/annotationsOnParenthesizedTypes.kt"); + doTest(fileName); + } + + @TestMetadata("splitModifierList.kt") + public void testSplitModifierList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/parenthesizedTypes/splitModifierList.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PlatformTypes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInPlatformTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("delegateByComplexInheritance.kt") + public void testDelegateByComplexInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/delegateByComplexInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("dereference.kt") + public void testDereference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/dereference.kt"); + doTest(fileName); + } + + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/elvis.kt"); + doTest(fileName); + } + + @TestMetadata("explicitFlexibleNoPackage.kt") + public void testExplicitFlexibleNoPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/explicitFlexibleNoPackage.kt"); + doTest(fileName); + } + + @TestMetadata("explicitFlexibleWithPackage.kt") + public void testExplicitFlexibleWithPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/explicitFlexibleWithPackage.kt"); + doTest(fileName); + } + + @TestMetadata("getParentOfType.kt") + public void testGetParentOfType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/getParentOfType.kt"); + doTest(fileName); + } + + @TestMetadata("inference.kt") + public void testInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/inference.kt"); + doTest(fileName); + } + + @TestMetadata("intVsIntegerAmbiguity.kt") + public void testIntVsIntegerAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("javaEmptyList.kt") + public void testJavaEmptyList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt"); + doTest(fileName); + } + + @TestMetadata("methodTypeParameterDefaultBound.kt") + public void testMethodTypeParameterDefaultBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodTypeParameterDefaultBound.kt"); + doTest(fileName); + } + + @TestMetadata("noAnnotationInClassPath.kt") + public void testNoAnnotationInClassPath() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/noAnnotationInClassPath.kt"); + doTest(fileName); + } + + @TestMetadata("nullableTypeArgument.kt") + public void testNullableTypeArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullableTypeArgument.kt"); + doTest(fileName); + } + + @TestMetadata("override.kt") + public void testOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/override.kt"); + doTest(fileName); + } + + @TestMetadata("rawOverrides.kt") + public void testRawOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("rawSamOverrides.kt") + public void testRawSamOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawSamOverrides.kt"); + doTest(fileName); + } + + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/safeCall.kt"); + doTest(fileName); + } + + @TestMetadata("samAdapterInConstructor.kt") + public void testSamAdapterInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/samAdapterInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("samConstructor.kt") + public void testSamConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/samConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("supertypeArgumentsExplicit.kt") + public void testSupertypeArgumentsExplicit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/supertypeArgumentsExplicit.kt"); + doTest(fileName); + } + + @TestMetadata("supertypeTypeArguments.kt") + public void testSupertypeTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CommonSupertype extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInCommonSupertype() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("collectionOrNull.kt") + public void testCollectionOrNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceWithBound.kt") + public void testInferenceWithBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.kt"); + doTest(fileName); + } + + @TestMetadata("mixedElvis.kt") + public void testMixedElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedElvis.kt"); + doTest(fileName); + } + + @TestMetadata("mixedIf.kt") + public void testMixedIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveGeneric.kt") + public void testRecursiveGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("stringOrNull.kt") + public void testStringOrNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.kt"); + doTest(fileName); + } + + @TestMetadata("typeOfElvis.kt") + public void testTypeOfElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.kt"); + doTest(fileName); + } + + @TestMetadata("withNothing.kt") + public void testWithNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class GenericVarianceViolation extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInGenericVarianceViolation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("listSuperType.kt") + public void testListSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/listSuperType.kt"); + doTest(fileName); + } + + @TestMetadata("rawTypes.kt") + public void testRawTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/rawTypes.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/simple.kt"); + doTest(fileName); + } + + @TestMetadata("smartCast.kt") + public void testSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt"); + doTest(fileName); + } + + @TestMetadata("strangeVariance.kt") + public void testStrangeVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/strangeVariance.kt"); + doTest(fileName); + } + + @TestMetadata("userDefinedOut.kt") + public void testUserDefinedOut() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/userDefinedOut.kt"); + doTest(fileName); + } + + @TestMetadata("valueFromJava.kt") + public void testValueFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/valueFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("wildcards.kt") + public void testWildcards() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/wildcards.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/intersection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Intersection extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInIntersection() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/intersection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("map.kt") + public void testMap() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/intersection/map.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MethodCall extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInMethodCall() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("entrySet.kt") + public void testEntrySet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.kt"); + doTest(fileName); + } + + @TestMetadata("genericsAndArrays.kt") + public void testGenericsAndArrays() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.kt"); + doTest(fileName); + } + + @TestMetadata("int.kt") + public void testInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/int.kt"); + doTest(fileName); + } + + @TestMetadata("intArray.kt") + public void testIntArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.kt"); + doTest(fileName); + } + + @TestMetadata("javaCollectionToKotlin.kt") + public void testJavaCollectionToKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaCollectionToKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("javaToJava.kt") + public void testJavaToJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.kt"); + doTest(fileName); + } + + @TestMetadata("javaToKotlin.kt") + public void testJavaToKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("kotlinCollectionToJava.kt") + public void testKotlinCollectionToJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/kotlinCollectionToJava.kt"); + doTest(fileName); + } + + @TestMetadata("list.kt") + public void testList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/list.kt"); + doTest(fileName); + } + + @TestMetadata("multipleExactBounds.kt") + public void testMultipleExactBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBounds.kt"); + doTest(fileName); + } + + @TestMetadata("multipleExactBoundsNullable.kt") + public void testMultipleExactBoundsNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt"); + doTest(fileName); + } + + @TestMetadata("objectArray.kt") + public void testObjectArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.kt"); + doTest(fileName); + } + + @TestMetadata("overloadingForSubclass.kt") + public void testOverloadingForSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt"); + doTest(fileName); + } + + @TestMetadata("sam.kt") + public void testSam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.kt"); + doTest(fileName); + } + + @TestMetadata("singleton.kt") + public void testSingleton() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt"); + doTest(fileName); + } + + @TestMetadata("string.kt") + public void testString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/string.kt"); + doTest(fileName); + } + + @TestMetadata("visitor.kt") + public void testVisitor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotNullTypeParameter extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNotNullTypeParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("enhancementFromAnnotation.kt") + public void testEnhancementFromAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/enhancementFromAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("enhancementFromKotlin.kt") + public void testEnhancementFromKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/enhancementFromKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("methodTypeParameter.kt") + public void testMethodTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("noInheritanceReturnType.kt") + public void testNoInheritanceReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("noInheritanceValueParameter.kt") + public void testNoInheritanceValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("onTypeProjection.kt") + public void testOnTypeProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/onTypeProjection.kt"); + doTest(fileName); + } + + @TestMetadata("substitutionInSuperType.kt") + public void testSubstitutionInSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NullabilityWarnings extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNullabilityWarnings() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arithmetic.kt") + public void testArithmetic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt"); + doTest(fileName); + } + + @TestMetadata("array.kt") + public void testArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt"); + doTest(fileName); + } + + @TestMetadata("assignToVar.kt") + public void testAssignToVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt"); + doTest(fileName); + } + + @TestMetadata("conditions.kt") + public void testConditions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt"); + doTest(fileName); + } + + @TestMetadata("dataFlowInfo.kt") + public void testDataFlowInfo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt"); + doTest(fileName); + } + + @TestMetadata("defaultParameters.kt") + public void testDefaultParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt"); + doTest(fileName); + } + + @TestMetadata("delegatedProperties.kt") + public void testDelegatedProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt"); + doTest(fileName); + } + + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt"); + doTest(fileName); + } + + @TestMetadata("derefenceExtension.kt") + public void testDerefenceExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt"); + doTest(fileName); + } + + @TestMetadata("derefenceMember.kt") + public void testDerefenceMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt"); + doTest(fileName); + } + + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt"); + doTest(fileName); + } + + @TestMetadata("expectedType.kt") + public void testExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt"); + doTest(fileName); + } + + @TestMetadata("for.kt") + public void testFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt"); + doTest(fileName); + } + + @TestMetadata("functionArguments.kt") + public void testFunctionArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceInConditionals.kt") + public void testInferenceInConditionals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt"); + doTest(fileName); + } + + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt"); + doTest(fileName); + } + + @TestMetadata("kt6829.kt") + public void testKt6829() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt"); + doTest(fileName); + } + + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("notNullAfterSafeCall.kt") + public void testNotNullAfterSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("notNullAssertion.kt") + public void testNotNullAssertion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt"); + doTest(fileName); + } + + @TestMetadata("notNullAssertionInCall.kt") + public void testNotNullAssertionInCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt"); + doTest(fileName); + } + + @TestMetadata("notNullTypeMarkedWithNullableAnnotation.kt") + public void testNotNullTypeMarkedWithNullableAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("passToJava.kt") + public void testPassToJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt"); + doTest(fileName); + } + + @TestMetadata("primitiveArray.kt") + public void testPrimitiveArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt"); + doTest(fileName); + } + + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt"); + doTest(fileName); + } + + @TestMetadata("senselessComparisonEquals.kt") + public void testSenselessComparisonEquals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt"); + doTest(fileName); + } + + @TestMetadata("senselessComparisonIdentityEquals.kt") + public void testSenselessComparisonIdentityEquals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt"); + doTest(fileName); + } + + @TestMetadata("throw.kt") + public void testThrow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt"); + doTest(fileName); + } + + @TestMetadata("uselessElvisInCall.kt") + public void testUselessElvisInCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt"); + doTest(fileName); + } + + @TestMetadata("uselessElvisRightIsNull.kt") + public void testUselessElvisRightIsNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisRightIsNull.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class RawTypes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInRawTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("arrays.kt") + public void testArrays() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt"); + doTest(fileName); + } + + @TestMetadata("errorType.kt") + public void testErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/errorType.kt"); + doTest(fileName); + } + + @TestMetadata("genericInnerClass.kt") + public void testGenericInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("interClassesRecursion.kt") + public void testInterClassesRecursion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/interClassesRecursion.kt"); + doTest(fileName); + } + + @TestMetadata("nonGenericRawMember.kt") + public void testNonGenericRawMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt"); + doTest(fileName); + } + + @TestMetadata("nonTrivialErasure.kt") + public void testNonTrivialErasure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonTrivialErasure.kt"); + doTest(fileName); + } + + @TestMetadata("rawEnhancment.kt") + public void testRawEnhancment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt"); + doTest(fileName); + } + + @TestMetadata("rawSupertype.kt") + public void testRawSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("rawSupertypeOverride.kt") + public void testRawSupertypeOverride() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertypeOverride.kt"); + doTest(fileName); + } + + @TestMetadata("rawTypeInUpperBound.kt") + public void testRawTypeInUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("rawWithInProjection.kt") + public void testRawWithInProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawWithInProjection.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveBound.kt") + public void testRecursiveBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/recursiveBound.kt"); + doTest(fileName); + } + + @TestMetadata("samRaw.kt") + public void testSamRaw() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt"); + doTest(fileName); + } + + @TestMetadata("saveRawCapabilitiesAfterSubtitution.kt") + public void testSaveRawCapabilitiesAfterSubtitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/saveRawCapabilitiesAfterSubtitution.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.kt"); + doTest(fileName); + } + + @TestMetadata("starProjectionToRaw.kt") + public void testStarProjectionToRaw() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/starProjectionToRaw.kt"); + doTest(fileName); + } + + @TestMetadata("typeEnhancement.kt") + public void testTypeEnhancement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancement extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTypeEnhancement() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("overriddenExtensions.kt") + public void testOverriddenExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("saveAnnotationAfterSubstitution.kt") + public void testSaveAnnotationAfterSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt"); + doTest(fileName); + } + + @TestMetadata("supertypeDifferentParameterNullability.kt") + public void testSupertypeDifferentParameterNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt"); + doTest(fileName); + } + + @TestMetadata("supertypeDifferentReturnNullability.kt") + public void testSupertypeDifferentReturnNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/privateInFile") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrivateInFile extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInPrivateInFile() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt12429.kt") + public void testKt12429() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/privateInFile/kt12429.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelAnnotationCall.kt") + public void testTopLevelAnnotationCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt"); + doTest(fileName); + } + + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/privateInFile/visibility.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/properties") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Properties extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInProperties() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("extensionPropertyMustHaveAccessorsOrBeAbstract.kt") + public void testExtensionPropertyMustHaveAccessorsOrBeAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/extensionPropertyMustHaveAccessorsOrBeAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InferenceFromGetters extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInferenceFromGetters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("blockBodyGetter.kt") + public void testBlockBodyGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/blockBodyGetter.kt"); + doTest(fileName); + } + + @TestMetadata("cantBeInferred.kt") + public void testCantBeInferred() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt"); + doTest(fileName); + } + + @TestMetadata("explicitGetterType.kt") + public void testExplicitGetterType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/explicitGetterType.kt"); + doTest(fileName); + } + + @TestMetadata("members.kt") + public void testMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/members.kt"); + doTest(fileName); + } + + @TestMetadata("nullAsNothing.kt") + public void testNullAsNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/nullAsNothing.kt"); + doTest(fileName); + } + + @TestMetadata("objectExpression.kt") + public void testObjectExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt"); + doTest(fileName); + } + + @TestMetadata("overrides.kt") + public void testOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/overrides.kt"); + doTest(fileName); + } + + @TestMetadata("primaryConstructorParameter.kt") + public void testPrimaryConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveGetter.kt") + public void testRecursiveGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt"); + doTest(fileName); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/topLevel.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedInferenceFromGetters.kt") + public void testUnsupportedInferenceFromGetters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt"); + doTest(fileName); + } + + @TestMetadata("vars.kt") + public void testVars() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/vars.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class QualifiedExpression extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("calleeExpressionAsCallExpression.kt") + public void testCalleeExpressionAsCallExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt"); + doTest(fileName); + } + + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); + doTest(fileName); + } + + @TestMetadata("JavaQualifier.kt") + public void testJavaQualifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/JavaQualifier.kt"); + doTest(fileName); + } + + @TestMetadata("nullCalleeExpression.kt") + public void testNullCalleeExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); + doTest(fileName); + } + + @TestMetadata("TypeWithError.kt") + public void testTypeWithError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt"); + doTest(fileName); + } + + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/reassignment") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Reassignment extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("afterfor.kt") + public void testAfterfor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/afterfor.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInReassignment() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("dowhile.kt") + public void testDowhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/dowhile.kt"); + doTest(fileName); + } + + @TestMetadata("else.kt") + public void testElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/else.kt"); + doTest(fileName); + } + + @TestMetadata("foronly.kt") + public void testForonly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/foronly.kt"); + doTest(fileName); + } + + @TestMetadata("if.kt") + public void testIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/if.kt"); + doTest(fileName); + } + + @TestMetadata("ifelse.kt") + public void testIfelse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/ifelse.kt"); + doTest(fileName); + } + + @TestMetadata("noifelse.kt") + public void testNoifelse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/noifelse.kt"); + doTest(fileName); + } + + @TestMetadata("when.kt") + public void testWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/when.kt"); + doTest(fileName); + } + + @TestMetadata("whiletrue.kt") + public void testWhiletrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reassignment/whiletrue.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/recovery") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Recovery extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("absentLeftHandSide.kt") + public void testAbsentLeftHandSide() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInRecovery() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("emptyTypeArgs.kt") + public void testEmptyTypeArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/recovery/emptyTypeArgs.kt"); + doTest(fileName); + } + + @TestMetadata("namelessInJava.kt") + public void testNamelessInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/recovery/namelessInJava.kt"); + doTest(fileName); + } + + @TestMetadata("namelessMembers.kt") + public void testNamelessMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/recovery/namelessMembers.kt"); + doTest(fileName); + } + + @TestMetadata("namelessToplevelDeclarations.kt") + public void testNamelessToplevelDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/redeclarations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Redeclarations extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInRedeclarations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassRedeclarationInDifferentFiles.kt") + public void testClassRedeclarationInDifferentFiles() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/ClassRedeclarationInDifferentFiles.kt"); + doTest(fileName); + } + + @TestMetadata("ConflictingExtensionProperties.kt") + public void testConflictingExtensionProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/ConflictingExtensionProperties.kt"); + doTest(fileName); + } + + @TestMetadata("DuplicateParameterNamesInFunctionType.kt") + public void testDuplicateParameterNamesInFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/DuplicateParameterNamesInFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("EnumName.kt") + public void testEnumName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/EnumName.kt"); + doTest(fileName); + } + + @TestMetadata("FunVsCtorInDifferentFiles.kt") + public void testFunVsCtorInDifferentFiles() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/FunVsCtorInDifferentFiles.kt"); + doTest(fileName); + } + + @TestMetadata("interfaceTypeParameters.kt") + public void testInterfaceTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/interfaceTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("kt2418.kt") + public void testKt2418() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/kt2418.kt"); + doTest(fileName); + } + + @TestMetadata("kt2438.kt") + public void testKt2438() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/kt2438.kt"); + doTest(fileName); + } + + @TestMetadata("kt470.kt") + public void testKt470() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/kt470.kt"); + doTest(fileName); + } + + @TestMetadata("MultiFilePackageRedeclaration.kt") + public void testMultiFilePackageRedeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt"); + doTest(fileName); + } + + @TestMetadata("NoRedeclarationForClassesInDefaultObject.kt") + public void testNoRedeclarationForClassesInDefaultObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/NoRedeclarationForClassesInDefaultObject.kt"); + doTest(fileName); + } + + @TestMetadata("NoRedeclarationForEnumEntriesAndDefaultObjectMembers.kt") + public void testNoRedeclarationForEnumEntriesAndDefaultObjectMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/NoRedeclarationForEnumEntriesAndDefaultObjectMembers.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyAndFunInClass.kt") + public void testPropertyAndFunInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/PropertyAndFunInClass.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyAndInnerClass.kt") + public void testPropertyAndInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/PropertyAndInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationInDefaultObject.kt") + public void testRedeclarationInDefaultObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclarationInDefaultObject.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationInMultiFile.kt") + public void testRedeclarationInMultiFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclarationInMultiFile.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationMainInFile.kt") + public void testRedeclarationMainInFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInFile.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationMainInMultiFile.kt") + public void testRedeclarationMainInMultiFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInMultiFile.kt"); + doTest(fileName); + } + + @TestMetadata("Redeclarations.kt") + public void testRedeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclarationsInObjects.kt") + public void testRedeclarationsInObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclarationsInObjects.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclaredTypeParameters.kt") + public void testRedeclaredTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclaredTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("RedeclaringPrivateToFile.kt") + public void testRedeclaringPrivateToFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.kt"); + doTest(fileName); + } + + @TestMetadata("ScriptAndClassConflict.kt") + public void testScriptAndClassConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/ScriptAndClassConflict.kt"); + doTest(fileName); + } + + @TestMetadata("SingletonAndFunctionSameName.kt") + public void testSingletonAndFunctionSameName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/SingletonAndFunctionSameName.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelPropertyVsClassifier.kt") + public void testTopLevelPropertyVsClassifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/TopLevelPropertyVsClassifier.kt"); + doTest(fileName); + } + + @TestMetadata("TypeAliasCtorVsFun.kt") + public void testTypeAliasCtorVsFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/TypeAliasCtorVsFun.kt"); + doTest(fileName); + } + + @TestMetadata("TypeAliasVsClass.kt") + public void testTypeAliasVsClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsClass.kt"); + doTest(fileName); + } + + @TestMetadata("TypeAliasVsProperty.kt") + public void testTypeAliasVsProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsProperty.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterWithTwoBounds.kt") + public void testTypeParameterWithTwoBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/typeParameterWithTwoBounds.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ShadowedExtension extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInShadowedExtension() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("extensionFunShadowedByInnerClassConstructor.kt") + public void testExtensionFunShadowedByInnerClassConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByInnerClassConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFunShadowedByMemberFun.kt") + public void testExtensionFunShadowedByMemberFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByMemberFun.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFunShadowedByMemberPropertyWithInvoke.kt") + public void testExtensionFunShadowedByMemberPropertyWithInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByMemberPropertyWithInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFunShadowedBySynthesizedMemberFun.kt") + public void testExtensionFunShadowedBySynthesizedMemberFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedBySynthesizedMemberFun.kt"); + doTest(fileName); + } + + @TestMetadata("extensionFunVsMemberExtensionFun.kt") + public void testExtensionFunVsMemberExtensionFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunVsMemberExtensionFun.kt"); + doTest(fileName); + } + + @TestMetadata("extensionOnErrorType.kt") + public void testExtensionOnErrorType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnErrorType.kt"); + doTest(fileName); + } + + @TestMetadata("extensionOnNullableReceiver.kt") + public void testExtensionOnNullableReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnNullableReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("extensionPropertyShadowedByMemberProperty.kt") + public void testExtensionPropertyShadowedByMemberProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionPropertyShadowedByMemberProperty.kt"); + doTest(fileName); + } + + @TestMetadata("extensionShadowedByDelegatedMember.kt") + public void testExtensionShadowedByDelegatedMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionShadowedByDelegatedMember.kt"); + doTest(fileName); + } + + @TestMetadata("extensionVsNonPublicMember.kt") + public void testExtensionVsNonPublicMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionVsNonPublicMember.kt"); + doTest(fileName); + } + + @TestMetadata("infixExtensionVsNonInfixMember.kt") + public void testInfixExtensionVsNonInfixMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt"); + doTest(fileName); + } + + @TestMetadata("localExtensionShadowedByMember.kt") + public void testLocalExtensionShadowedByMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/localExtensionShadowedByMember.kt"); + doTest(fileName); + } + + @TestMetadata("memberExtensionShadowedByMember.kt") + public void testMemberExtensionShadowedByMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/memberExtensionShadowedByMember.kt"); + doTest(fileName); + } + + @TestMetadata("operatorExtensionVsNonOperatorMember.kt") + public void testOperatorExtensionVsNonOperatorMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/operatorExtensionVsNonOperatorMember.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/reflection") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Reflection extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInReflection() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/reflection"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("noReflectionInClassPath.kt") + public void testNoReflectionInClassPath() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/reflection/noReflectionInClassPath.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/regressions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Regressions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInRegressions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AmbiguityOnLazyTypeComputation.kt") + public void testAmbiguityOnLazyTypeComputation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/AmbiguityOnLazyTypeComputation.kt"); + doTest(fileName); + } + + @TestMetadata("AssignmentsUnderOperators.kt") + public void testAssignmentsUnderOperators() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/AssignmentsUnderOperators.kt"); + doTest(fileName); + } + + @TestMetadata("CoercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/CoercionToUnit.kt"); + doTest(fileName); + } + + @TestMetadata("DoubleDefine.kt") + public void testDoubleDefine() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/DoubleDefine.kt"); + doTest(fileName); + } + + @TestMetadata("ea40964.kt") + public void testEa40964() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea40964.kt"); + doTest(fileName); + } + + @TestMetadata("ea43298.kt") + public void testEa43298() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea43298.kt"); + doTest(fileName); + } + + @TestMetadata("ea53340.kt") + public void testEa53340() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea53340.kt"); + doTest(fileName); + } + + @TestMetadata("ea65509.kt") + public void testEa65509() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea65509.kt"); + doTest(fileName); + } + + @TestMetadata("ea66984.kt") + public void testEa66984() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea66984.kt"); + doTest(fileName); + } + + @TestMetadata("ea69735.kt") + public void testEa69735() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea69735.kt"); + doTest(fileName); + } + + @TestMetadata("ea72837.kt") + public void testEa72837() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea72837.kt"); + doTest(fileName); + } + + @TestMetadata("ea76264.kt") + public void testEa76264() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ea76264.kt"); + doTest(fileName); + } + + @TestMetadata("ErrorsOnIbjectExpressionsAsParameters.kt") + public void testErrorsOnIbjectExpressionsAsParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/ErrorsOnIbjectExpressionsAsParameters.kt"); + doTest(fileName); + } + + @TestMetadata("intchar.kt") + public void testIntchar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/intchar.kt"); + doTest(fileName); + } + + @TestMetadata("itselfAsUpperBound.kt") + public void testItselfAsUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("itselfAsUpperBoundInClass.kt") + public void testItselfAsUpperBoundInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundInClass.kt"); + doTest(fileName); + } + + @TestMetadata("itselfAsUpperBoundInClassNotNull.kt") + public void testItselfAsUpperBoundInClassNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundInClassNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("itselfAsUpperBoundLocal.kt") + public void testItselfAsUpperBoundLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt"); + doTest(fileName); + } + + @TestMetadata("itselfAsUpperBoundMember.kt") + public void testItselfAsUpperBoundMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundMember.kt"); + doTest(fileName); + } + + @TestMetadata("itselfAsUpperBoundNotNull.kt") + public void testItselfAsUpperBoundNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("Jet11.kt") + public void testJet11() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet11.kt"); + doTest(fileName); + } + + @TestMetadata("Jet121.kt") + public void testJet121() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet121.kt"); + doTest(fileName); + } + + @TestMetadata("Jet124.kt") + public void testJet124() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet124.kt"); + doTest(fileName); + } + + @TestMetadata("Jet169.kt") + public void testJet169() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet169.kt"); + doTest(fileName); + } + + @TestMetadata("Jet17.kt") + public void testJet17() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet17.kt"); + doTest(fileName); + } + + @TestMetadata("Jet183.kt") + public void testJet183() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet183.kt"); + doTest(fileName); + } + + @TestMetadata("Jet183-1.kt") + public void testJet183_1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet183-1.kt"); + doTest(fileName); + } + + @TestMetadata("Jet53.kt") + public void testJet53() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet53.kt"); + doTest(fileName); + } + + @TestMetadata("Jet67.kt") + public void testJet67() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet67.kt"); + doTest(fileName); + } + + @TestMetadata("Jet68.kt") + public void testJet68() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet68.kt"); + doTest(fileName); + } + + @TestMetadata("Jet69.kt") + public void testJet69() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet69.kt"); + doTest(fileName); + } + + @TestMetadata("Jet72.kt") + public void testJet72() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet72.kt"); + doTest(fileName); + } + + @TestMetadata("Jet81.kt") + public void testJet81() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/Jet81.kt"); + doTest(fileName); + } + + @TestMetadata("kt10243.kt") + public void testKt10243() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt10243.kt"); + doTest(fileName); + } + + @TestMetadata("kt10243a.kt") + public void testKt10243a() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt10243a.kt"); + doTest(fileName); + } + + @TestMetadata("kt10633.kt") + public void testKt10633() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt10633.kt"); + doTest(fileName); + } + + @TestMetadata("kt10824.kt") + public void testKt10824() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt10824.kt"); + doTest(fileName); + } + + @TestMetadata("kt10843.kt") + public void testKt10843() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt10843.kt"); + doTest(fileName); + } + + @TestMetadata("kt127.kt") + public void testKt127() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt127.kt"); + doTest(fileName); + } + + @TestMetadata("kt128.kt") + public void testKt128() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt128.kt"); + doTest(fileName); + } + + @TestMetadata("kt13685.kt") + public void testKt13685() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt13685.kt"); + doTest(fileName); + } + + @TestMetadata("kt13954.kt") + public void testKt13954() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt13954.kt"); + doTest(fileName); + } + + @TestMetadata("kt14740.kt") + public void testKt14740() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt14740.kt"); + doTest(fileName); + } + + @TestMetadata("kt1489_1728.kt") + public void testKt1489_1728() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt"); + doTest(fileName); + } + + @TestMetadata("kt1550.kt") + public void testKt1550() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt1550.kt"); + doTest(fileName); + } + + @TestMetadata("kt16086.kt") + public void testKt16086() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt16086.kt"); + doTest(fileName); + } + + @TestMetadata("kt16086_2.kt") + public void testKt16086_2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt16086_2.kt"); + doTest(fileName); + } + + @TestMetadata("kt1639-JFrame.kt") + public void testKt1639_JFrame() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt"); + doTest(fileName); + } + + @TestMetadata("kt1647.kt") + public void testKt1647() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt1647.kt"); + doTest(fileName); + } + + @TestMetadata("kt1736.kt") + public void testKt1736() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt1736.kt"); + doTest(fileName); + } + + @TestMetadata("kt174.kt") + public void testKt174() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt174.kt"); + doTest(fileName); + } + + @TestMetadata("kt201.kt") + public void testKt201() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt201.kt"); + doTest(fileName); + } + + @TestMetadata("kt235.kt") + public void testKt235() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt235.kt"); + doTest(fileName); + } + + @TestMetadata("kt2376.kt") + public void testKt2376() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt2376.kt"); + doTest(fileName); + } + + @TestMetadata("kt251.kt") + public void testKt251() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt251.kt"); + doTest(fileName); + } + + @TestMetadata("kt258.kt") + public void testKt258() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt258.kt"); + doTest(fileName); + } + + @TestMetadata("kt26.kt") + public void testKt26() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt26.kt"); + doTest(fileName); + } + + @TestMetadata("kt26-1.kt") + public void testKt26_1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt26-1.kt"); + doTest(fileName); + } + + @TestMetadata("kt2768.kt") + public void testKt2768() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt2768.kt"); + doTest(fileName); + } + + @TestMetadata("kt282.kt") + public void testKt282() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt282.kt"); + doTest(fileName); + } + + @TestMetadata("kt287.kt") + public void testKt287() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt287.kt"); + doTest(fileName); + } + + @TestMetadata("kt2956.kt") + public void testKt2956() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt2956.kt"); + doTest(fileName); + } + + @TestMetadata("kt302.kt") + public void testKt302() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt302.kt"); + doTest(fileName); + } + + @TestMetadata("kt306.kt") + public void testKt306() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt306.kt"); + doTest(fileName); + } + + @TestMetadata("kt307.kt") + public void testKt307() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt307.kt"); + doTest(fileName); + } + + @TestMetadata("kt312.kt") + public void testKt312() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt312.kt"); + doTest(fileName); + } + + @TestMetadata("kt313.kt") + public void testKt313() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt313.kt"); + doTest(fileName); + } + + @TestMetadata("kt316.kt") + public void testKt316() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt316.kt"); + doTest(fileName); + } + + @TestMetadata("kt328.kt") + public void testKt328() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt328.kt"); + doTest(fileName); + } + + @TestMetadata("kt334.kt") + public void testKt334() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt334.kt"); + doTest(fileName); + } + + @TestMetadata("kt335.336.kt") + public void testKt335_336() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt335.336.kt"); + doTest(fileName); + } + + @TestMetadata("kt337.kt") + public void testKt337() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt337.kt"); + doTest(fileName); + } + + @TestMetadata("kt352.kt") + public void testKt352() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt352.kt"); + doTest(fileName); + } + + @TestMetadata("kt353.kt") + public void testKt353() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt353.kt"); + doTest(fileName); + } + + @TestMetadata("kt3535.kt") + public void testKt3535() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt3535.kt"); + doTest(fileName); + } + + @TestMetadata("kt3647.kt") + public void testKt3647() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt3647.kt"); + doTest(fileName); + } + + @TestMetadata("kt3731.kt") + public void testKt3731() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt3731.kt"); + doTest(fileName); + } + + @TestMetadata("kt3810.kt") + public void testKt3810() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt3810.kt"); + doTest(fileName); + } + + @TestMetadata("kt385.109.441.kt") + public void testKt385_109_441() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt385.109.441.kt"); + doTest(fileName); + } + + @TestMetadata("kt394.kt") + public void testKt394() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt394.kt"); + doTest(fileName); + } + + @TestMetadata("kt398.kt") + public void testKt398() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt398.kt"); + doTest(fileName); + } + + @TestMetadata("kt399.kt") + public void testKt399() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt399.kt"); + doTest(fileName); + } + + @TestMetadata("kt402.kt") + public void testKt402() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt402.kt"); + doTest(fileName); + } + + @TestMetadata("kt41.kt") + public void testKt41() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt41.kt"); + doTest(fileName); + } + + @TestMetadata("kt411.kt") + public void testKt411() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt411.kt"); + doTest(fileName); + } + + @TestMetadata("kt439.kt") + public void testKt439() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt439.kt"); + doTest(fileName); + } + + @TestMetadata("kt442.kt") + public void testKt442() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt442.kt"); + doTest(fileName); + } + + @TestMetadata("kt443.kt") + public void testKt443() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt443.kt"); + doTest(fileName); + } + + @TestMetadata("kt455.kt") + public void testKt455() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt455.kt"); + doTest(fileName); + } + + @TestMetadata("kt456.kt") + public void testKt456() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt456.kt"); + doTest(fileName); + } + + @TestMetadata("kt459.kt") + public void testKt459() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt459.kt"); + doTest(fileName); + } + + @TestMetadata("kt469.kt") + public void testKt469() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt469.kt"); + doTest(fileName); + } + + @TestMetadata("kt4693.kt") + public void testKt4693() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt4693.kt"); + doTest(fileName); + } + + @TestMetadata("kt4827.kt") + public void testKt4827() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt4827.kt"); + doTest(fileName); + } + + @TestMetadata("kt498.kt") + public void testKt498() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt498.kt"); + doTest(fileName); + } + + @TestMetadata("kt524.kt") + public void testKt524() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt524.kt"); + doTest(fileName); + } + + @TestMetadata("kt526UnresolvedReferenceInnerStatic.kt") + public void testKt526UnresolvedReferenceInnerStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt526UnresolvedReferenceInnerStatic.kt"); + doTest(fileName); + } + + @TestMetadata("kt5326.kt") + public void testKt5326() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt5326.kt"); + doTest(fileName); + } + + @TestMetadata("kt5362.kt") + public void testKt5362() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt5362.kt"); + doTest(fileName); + } + + @TestMetadata("kt549.kt") + public void testKt549() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt549.kt"); + doTest(fileName); + } + + @TestMetadata("kt557.kt") + public void testKt557() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt557.kt"); + doTest(fileName); + } + + @TestMetadata("kt571.kt") + public void testKt571() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt571.kt"); + doTest(fileName); + } + + @TestMetadata("kt575.kt") + public void testKt575() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt575.kt"); + doTest(fileName); + } + + @TestMetadata("kt58.kt") + public void testKt58() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt58.kt"); + doTest(fileName); + } + + @TestMetadata("kt580.kt") + public void testKt580() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt580.kt"); + doTest(fileName); + } + + @TestMetadata("kt588.kt") + public void testKt588() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt588.kt"); + doTest(fileName); + } + + @TestMetadata("kt597.kt") + public void testKt597() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt597.kt"); + doTest(fileName); + } + + @TestMetadata("kt600.kt") + public void testKt600() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt600.kt"); + doTest(fileName); + } + + @TestMetadata("kt604.kt") + public void testKt604() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt604.kt"); + doTest(fileName); + } + + @TestMetadata("kt618.kt") + public void testKt618() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt618.kt"); + doTest(fileName); + } + + @TestMetadata("kt629.kt") + public void testKt629() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt629.kt"); + doTest(fileName); + } + + @TestMetadata("kt630.kt") + public void testKt630() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt630.kt"); + doTest(fileName); + } + + @TestMetadata("kt6508.kt") + public void testKt6508() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt6508.kt"); + doTest(fileName); + } + + @TestMetadata("kt688.kt") + public void testKt688() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt688.kt"); + doTest(fileName); + } + + @TestMetadata("kt691.kt") + public void testKt691() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt691.kt"); + doTest(fileName); + } + + @TestMetadata("kt701.kt") + public void testKt701() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt701.kt"); + doTest(fileName); + } + + @TestMetadata("kt716.kt") + public void testKt716() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt716.kt"); + doTest(fileName); + } + + @TestMetadata("kt743.kt") + public void testKt743() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt743.kt"); + doTest(fileName); + } + + @TestMetadata("kt750.kt") + public void testKt750() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt750.kt"); + doTest(fileName); + } + + @TestMetadata("kt762.kt") + public void testKt762() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt762.kt"); + doTest(fileName); + } + + @TestMetadata("kt7804.kt") + public void testKt7804() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt7804.kt"); + doTest(fileName); + } + + @TestMetadata("kt847.kt") + public void testKt847() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt847.kt"); + doTest(fileName); + } + + @TestMetadata("kt860.kt") + public void testKt860() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt860.kt"); + doTest(fileName); + } + + @TestMetadata("kt9620.kt") + public void testKt9620() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt9620.kt"); + doTest(fileName); + } + + @TestMetadata("kt9633.kt") + public void testKt9633() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt9633.kt"); + doTest(fileName); + } + + @TestMetadata("kt9682.kt") + public void testKt9682() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt9682.kt"); + doTest(fileName); + } + + @TestMetadata("kt9808.kt") + public void testKt9808() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt9808.kt"); + doTest(fileName); + } + + @TestMetadata("noThis.kt") + public void testNoThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/noThis.kt"); + doTest(fileName); + } + + @TestMetadata("OrphanStarProjection.kt") + public void testOrphanStarProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt"); + doTest(fileName); + } + + @TestMetadata("OutProjections.kt") + public void testOutProjections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/OutProjections.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideResolution.kt") + public void testOverrideResolution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/OverrideResolution.kt"); + doTest(fileName); + } + + @TestMetadata("resolveSubclassOfList.kt") + public void testResolveSubclassOfList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/resolveSubclassOfList.kt"); + doTest(fileName); + } + + @TestMetadata("SpecififcityByReceiver.kt") + public void testSpecififcityByReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/SpecififcityByReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("TypeMismatchOnUnaryOperations.kt") + public void testTypeMismatchOnUnaryOperations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParameterAsASupertype.kt") + public void testTypeParameterAsASupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/TypeParameterAsASupertype.kt"); + doTest(fileName); + } + + @TestMetadata("UnavaliableQualifiedThis.kt") + public void testUnavaliableQualifiedThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/UnavaliableQualifiedThis.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTraceInCallResolver.kt") + public void testWrongTraceInCallResolver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/WrongTraceInCallResolver.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/regressions/kt7585") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt7585 extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInKt7585() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("base.kt") + public void testBase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt7585/base.kt"); + doTest(fileName); + } + + @TestMetadata("java.kt") + public void testJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt7585/java.kt"); + doTest(fileName); + } + + @TestMetadata("twoparents.kt") + public void testTwoparents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/regressions/kt7585/twoparents.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Resolve extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInResolve() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguityOnPropertiesWithTheSamePackageName.kt") + public void testAmbiguityOnPropertiesWithTheSamePackageName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/ambiguityOnPropertiesWithTheSamePackageName.kt"); + doTest(fileName); + } + + @TestMetadata("ambiguityWithTwoCorrespondingFunctionTypes.kt") + public void testAmbiguityWithTwoCorrespondingFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("anonymousObjectFromTopLevelMember.kt") + public void testAnonymousObjectFromTopLevelMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/anonymousObjectFromTopLevelMember.kt"); + doTest(fileName); + } + + @TestMetadata("capturedTypesInLambdaParameter.kt") + public void testCapturedTypesInLambdaParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/capturedTypesInLambdaParameter.kt"); + doTest(fileName); + } + + @TestMetadata("constructorVsCompanion.kt") + public void testConstructorVsCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("CycleInTypeArgs.kt") + public void testCycleInTypeArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/CycleInTypeArgs.kt"); + doTest(fileName); + } + + @TestMetadata("HiddenDeclarations.kt") + public void testHiddenDeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("implicitReceiverProperty.kt") + public void testImplicitReceiverProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.kt"); + doTest(fileName); + } + + @TestMetadata("incompleteConstructorInvocation.kt") + public void testIncompleteConstructorInvocation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceInLinkedLambdas.kt") + public void testInferenceInLinkedLambdas() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceInLinkedLambdasDependentOnExpectedType.kt") + public void testInferenceInLinkedLambdasDependentOnExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("localObject.kt") + public void testLocalObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/localObject.kt"); + doTest(fileName); + } + + @TestMetadata("objectLiteralAsArgument.kt") + public void testObjectLiteralAsArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/objectLiteralAsArgument.kt"); + doTest(fileName); + } + + @TestMetadata("parameterAsDefaultValueInLocalFunction.kt") + public void testParameterAsDefaultValueInLocalFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/parameterAsDefaultValueInLocalFunction.kt"); + doTest(fileName); + } + + @TestMetadata("resolveAnnotatedLambdaArgument.kt") + public void testResolveAnnotatedLambdaArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt"); + doTest(fileName); + } + + @TestMetadata("resolveTypeArgsForUnresolvedCall.kt") + public void testResolveTypeArgsForUnresolvedCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveTypeArgsForUnresolvedCall.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithFunctionLiteralWithId.kt") + public void testResolveWithFunctionLiteralWithId() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithFunctionLiterals.kt") + public void testResolveWithFunctionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithFunctionLiteralsOverload.kt") + public void testResolveWithFunctionLiteralsOverload() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralsOverload.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithGenerics.kt") + public void testResolveWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithRedeclarationError.kt") + public void testResolveWithRedeclarationError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithRedeclarationError.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithSpecifiedFunctionLiteralWithId.kt") + public void testResolveWithSpecifiedFunctionLiteralWithId() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt"); + doTest(fileName); + } + + @TestMetadata("resolveWithoutGenerics.kt") + public void testResolveWithoutGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/resolveWithoutGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("typeParameterInDefaultValueInLocalFunction.kt") + public void testTypeParameterInDefaultValueInLocalFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/typeParameterInDefaultValueInLocalFunction.kt"); + doTest(fileName); + } + + @TestMetadata("wrongNumberOfTypeArguments.kt") + public void testWrongNumberOfTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("wrongReceiver.kt") + public void testWrongReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/wrongReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DslMarker extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDslMarker() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotatedTypeArgument.kt") + public void testAnnotatedTypeArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt"); + doTest(fileName); + } + + @TestMetadata("inheritedMarker.kt") + public void testInheritedMarker() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt"); + doTest(fileName); + } + + @TestMetadata("insideTopLevelExtension.kt") + public void testInsideTopLevelExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt"); + doTest(fileName); + } + + @TestMetadata("insideTopLevelExtensionAnnotatedType.kt") + public void testInsideTopLevelExtensionAnnotatedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt"); + doTest(fileName); + } + + @TestMetadata("markersIntersection.kt") + public void testMarkersIntersection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt"); + doTest(fileName); + } + + @TestMetadata("nestedWithSameReceiver.kt") + public void testNestedWithSameReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt"); + doTest(fileName); + } + + @TestMetadata("simpleAnnotatedClasses.kt") + public void testSimpleAnnotatedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("simpleAnnotatedTypes.kt") + public void testSimpleAnnotatedTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt"); + doTest(fileName); + } + + @TestMetadata("substitutedReceiverAnnotatedClasses.kt") + public void testSubstitutedReceiverAnnotatedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("substitutedReceiverAnnotatedType.kt") + public void testSubstitutedReceiverAnnotatedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt"); + doTest(fileName); + } + + @TestMetadata("threeImplicitReceivers.kt") + public void testThreeImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("threeImplicitReceivers2.kt") + public void testThreeImplicitReceivers2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt"); + doTest(fileName); + } + + @TestMetadata("twoImplicitReceivers.kt") + public void testTwoImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("twoLanguages.kt") + public void testTwoLanguages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedFeature.kt") + public void testUnsupportedFeature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/unsupportedFeature.kt"); + doTest(fileName); + } + + @TestMetadata("useOfExtensions.kt") + public void testUseOfExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("usingWith.kt") + public void testUsingWith() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt"); + doTest(fileName); + } + + @TestMetadata("usingWithThis.kt") + public void testUsingWithThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Invoke extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInvoke() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("extensionValueAsNonExtension.kt") + public void testExtensionValueAsNonExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt"); + doTest(fileName); + } + + @TestMetadata("functionExpectedWhenSeveralInvokesExist.kt") + public void testFunctionExpectedWhenSeveralInvokesExist() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvoke.kt") + public void testImplicitInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/implicitInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("invokeAndSmartCast.kt") + public void testInvokeAndSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("invokeAsExtension.kt") + public void testInvokeAsExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt"); + doTest(fileName); + } + + @TestMetadata("invokeAsMember.kt") + public void testInvokeAsMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt"); + doTest(fileName); + } + + @TestMetadata("invokeAsMemberExtension.kt") + public void testInvokeAsMemberExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt"); + doTest(fileName); + } + + @TestMetadata("invokeAsMemberExtensionToExplicitReceiver.kt") + public void testInvokeAsMemberExtensionToExplicitReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("invokeNonExtensionLambdaInContext.kt") + public void testInvokeNonExtensionLambdaInContext() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeNonExtensionLambdaInContext.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnVariableWithExtensionFunctionType.kt") + public void testInvokeOnVariableWithExtensionFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt"); + doTest(fileName); + } + + @TestMetadata("KT-4372.kt") + public void testKT_4372() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/KT-4372.kt"); + doTest(fileName); + } + + @TestMetadata("kt3772.kt") + public void testKt3772() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/kt3772.kt"); + doTest(fileName); + } + + @TestMetadata("kt3833-invokeInsideNestedClass.kt") + public void testKt3833_invokeInsideNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/kt3833-invokeInsideNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("kt4204-completeNestedCallsForInvoke.kt") + public void testKt4204_completeNestedCallsForInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/kt4204-completeNestedCallsForInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("kt4321InvokeOnEnum.kt") + public void testKt4321InvokeOnEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/kt4321InvokeOnEnum.kt"); + doTest(fileName); + } + + @TestMetadata("kt9517.kt") + public void testKt9517() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/kt9517.kt"); + doTest(fileName); + } + + @TestMetadata("kt9805.kt") + public void testKt9805() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt"); + doTest(fileName); + } + + @TestMetadata("reportFunctionExpectedWhenOneInvokeExist.kt") + public void testReportFunctionExpectedWhenOneInvokeExist() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt"); + doTest(fileName); + } + + @TestMetadata("valNamedInvoke.kt") + public void testValNamedInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/valNamedInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("wrongInvokeExtension.kt") + public void testWrongInvokeExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Errors extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInErrors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguityForInvoke.kt") + public void testAmbiguityForInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("invisibleInvoke.kt") + public void testInvisibleInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("receiverPresenceErrorForInvoke.kt") + public void testReceiverPresenceErrorForInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("typeInferenceErrorForInvoke.kt") + public void testTypeInferenceErrorForInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedInvoke.kt") + public void testUnresolvedInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("unsafeCallWithInvoke.kt") + public void testUnsafeCallWithInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("wrongReceiverForInvokeOnExpression.kt") + public void testWrongReceiverForInvokeOnExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt"); + doTest(fileName); + } + + @TestMetadata("wrongReceiverTypeForInvoke.kt") + public void testWrongReceiverTypeForInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NestedCalls extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNestedCalls() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("analyzeArgsInFreeExpressionPosition.kt") + public void testAnalyzeArgsInFreeExpressionPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeArgsInFreeExpressionPosition.kt"); + doTest(fileName); + } + + @TestMetadata("analyzeUnmappedArguments.kt") + public void testAnalyzeUnmappedArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeUnmappedArguments.kt"); + doTest(fileName); + } + + @TestMetadata("argumentsInParentheses.kt") + public void testArgumentsInParentheses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/argumentsInParentheses.kt"); + doTest(fileName); + } + + @TestMetadata("completeTypeInferenceForNestedInNoneApplicable.kt") + public void testCompleteTypeInferenceForNestedInNoneApplicable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt"); + doTest(fileName); + } + + @TestMetadata("completeUnmappedArguments.kt") + public void testCompleteUnmappedArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.kt"); + doTest(fileName); + } + + @TestMetadata("kt5971NestedSafeCall.kt") + public void testKt5971NestedSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("kt7597.kt") + public void testKt7597() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt"); + doTest(fileName); + } + + @TestMetadata("twoTypeParameters.kt") + public void testTwoTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/noCandidates") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NoCandidates extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNoCandidates() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt2787.kt") + public void testKt2787() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/noCandidates/kt2787.kt"); + doTest(fileName); + } + + @TestMetadata("resolvedToClassifier.kt") + public void testResolvedToClassifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt"); + doTest(fileName); + } + + @TestMetadata("resolvedToClassifierWithReceiver.kt") + public void testResolvedToClassifierWithReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OverloadConflicts extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOverloadConflicts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("allLambdas.kt") + public void testAllLambdas() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt"); + doTest(fileName); + } + + @TestMetadata("extensionReceiverAndVarargs.kt") + public void testExtensionReceiverAndVarargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/extensionReceiverAndVarargs.kt"); + doTest(fileName); + } + + @TestMetadata("genericWithProjection.kt") + public void testGenericWithProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericWithProjection.kt"); + doTest(fileName); + } + + @TestMetadata("kt10472.kt") + public void testKt10472() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.kt"); + doTest(fileName); + } + + @TestMetadata("kt10640.kt") + public void testKt10640() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt"); + doTest(fileName); + } + + @TestMetadata("numberOfDefaults.kt") + public void testNumberOfDefaults() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/numberOfDefaults.kt"); + doTest(fileName); + } + + @TestMetadata("originalExamples.kt") + public void testOriginalExamples() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.kt"); + doTest(fileName); + } + + @TestMetadata("varargWithMoreSpecificSignature.kt") + public void testVarargWithMoreSpecificSignature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargWithMoreSpecificSignature.kt"); + doTest(fileName); + } + + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargs.kt"); + doTest(fileName); + } + + @TestMetadata("varargsInDifferentPositions.kt") + public void testVarargsInDifferentPositions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsInDifferentPositions.kt"); + doTest(fileName); + } + + @TestMetadata("varargsMixed.kt") + public void testVarargsMixed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt"); + doTest(fileName); + } + + @TestMetadata("varargsWithRecursiveGenerics.kt") + public void testVarargsWithRecursiveGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("withVariance.kt") + public void testWithVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/priority") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Priority extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInPriority() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("invokeExtensionVsOther.kt") + public void testInvokeExtensionVsOther() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/invokeExtensionVsOther.kt"); + doTest(fileName); + } + + @TestMetadata("invokeExtensionVsOther2.kt") + public void testInvokeExtensionVsOther2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/invokeExtensionVsOther2.kt"); + doTest(fileName); + } + + @TestMetadata("kt10219.kt") + public void testKt10219() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/kt10219.kt"); + doTest(fileName); + } + + @TestMetadata("kt10510.kt") + public void testKt10510() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/kt10510.kt"); + doTest(fileName); + } + + @TestMetadata("kt9810.kt") + public void testKt9810() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/kt9810.kt"); + doTest(fileName); + } + + @TestMetadata("kt9965.kt") + public void testKt9965() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/kt9965.kt"); + doTest(fileName); + } + + @TestMetadata("localExtVsNonLocalExt.kt") + public void testLocalExtVsNonLocalExt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/localExtVsNonLocalExt.kt"); + doTest(fileName); + } + + @TestMetadata("memberVsLocalExt.kt") + public void testMemberVsLocalExt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/memberVsLocalExt.kt"); + doTest(fileName); + } + + @TestMetadata("staticVsImplicitReceiverMember.kt") + public void testStaticVsImplicitReceiverMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/staticVsImplicitReceiverMember.kt"); + doTest(fileName); + } + + @TestMetadata("synthesizedMembersVsExtension.kt") + public void testSynthesizedMembersVsExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/synthesizedMembersVsExtension.kt"); + doTest(fileName); + } + + @TestMetadata("syntheticPropertiesVsExtensions.kt") + public void testSyntheticPropertiesVsExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/syntheticPropertiesVsExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("syntheticPropertiesVsMembers.kt") + public void testSyntheticPropertiesVsMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/priority/syntheticPropertiesVsMembers.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SpecialConstructions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSpecialConstructions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("constantsInIf.kt") + public void testConstantsInIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt"); + doTest(fileName); + } + + @TestMetadata("elvisAsCall.kt") + public void testElvisAsCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt"); + doTest(fileName); + } + + @TestMetadata("exclExclAsCall.kt") + public void testExclExclAsCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt"); + doTest(fileName); + } + + @TestMetadata("inferenceForElvis.kt") + public void testInferenceForElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions/inferenceForElvis.kt"); + doTest(fileName); + } + + @TestMetadata("multipleSuperClasses.kt") + public void testMultipleSuperClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt"); + doTest(fileName); + } + + @TestMetadata("reportTypeMismatchDeeplyOnBranches.kt") + public void testReportTypeMismatchDeeplyOnBranches() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/scopes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Scopes extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInScopes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AmbiguityBetweenRootAndPackage.kt") + public void testAmbiguityBetweenRootAndPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt"); + doTest(fileName); + } + + @TestMetadata("AmbiguousNonExtensions.kt") + public void testAmbiguousNonExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/AmbiguousNonExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("genericVsNested.kt") + public void testGenericVsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/genericVsNested.kt"); + doTest(fileName); + } + + @TestMetadata("implicitReceiverMemberVsParameter.kt") + public void testImplicitReceiverMemberVsParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/implicitReceiverMemberVsParameter.kt"); + doTest(fileName); + } + + @TestMetadata("initializerScopeOfExtensionProperty.kt") + public void testInitializerScopeOfExtensionProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt"); + doTest(fileName); + } + + @TestMetadata("invisibleSetter.kt") + public void testInvisibleSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/invisibleSetter.kt"); + doTest(fileName); + } + + @TestMetadata("kt1078.kt") + public void testKt1078() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1078.kt"); + doTest(fileName); + } + + @TestMetadata("kt1080.kt") + public void testKt1080() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1080.kt"); + doTest(fileName); + } + + @TestMetadata("kt1244.kt") + public void testKt1244() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1244.kt"); + doTest(fileName); + } + + @TestMetadata("kt1248.kt") + public void testKt1248() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1248.kt"); + doTest(fileName); + } + + @TestMetadata("kt151.kt") + public void testKt151() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt151.kt"); + doTest(fileName); + } + + @TestMetadata("kt1579.kt") + public void testKt1579() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1579.kt"); + doTest(fileName); + } + + @TestMetadata("kt1579_map_entry.kt") + public void testKt1579_map_entry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1579_map_entry.kt"); + doTest(fileName); + } + + @TestMetadata("kt1580.kt") + public void testKt1580() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1580.kt"); + doTest(fileName); + } + + @TestMetadata("kt1642.kt") + public void testKt1642() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1642.kt"); + doTest(fileName); + } + + @TestMetadata("kt1738.kt") + public void testKt1738() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1738.kt"); + doTest(fileName); + } + + @TestMetadata("kt1805.kt") + public void testKt1805() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1805.kt"); + doTest(fileName); + } + + @TestMetadata("kt1806.kt") + public void testKt1806() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1806.kt"); + doTest(fileName); + } + + @TestMetadata("kt1822.kt") + public void testKt1822() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1822.kt"); + doTest(fileName); + } + + @TestMetadata("kt1942.kt") + public void testKt1942() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt1942.kt"); + doTest(fileName); + } + + @TestMetadata("kt2262.kt") + public void testKt2262() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt2262.kt"); + doTest(fileName); + } + + @TestMetadata("kt250.617.10.kt") + public void testKt250_617_10() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt250.617.10.kt"); + doTest(fileName); + } + + @TestMetadata("kt323.kt") + public void testKt323() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt323.kt"); + doTest(fileName); + } + + @TestMetadata("kt37.kt") + public void testKt37() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt37.kt"); + doTest(fileName); + } + + @TestMetadata("kt587.kt") + public void testKt587() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt587.kt"); + doTest(fileName); + } + + @TestMetadata("kt900.kt") + public void testKt900() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt900.kt"); + doTest(fileName); + } + + @TestMetadata("kt900-1.kt") + public void testKt900_1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt900-1.kt"); + doTest(fileName); + } + + @TestMetadata("kt900-2.kt") + public void testKt900_2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt900-2.kt"); + doTest(fileName); + } + + @TestMetadata("kt939.kt") + public void testKt939() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt939.kt"); + doTest(fileName); + } + + @TestMetadata("kt9430.kt") + public void testKt9430() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/kt9430.kt"); + doTest(fileName); + } + + @TestMetadata("NoAmbiguityBetweenRootAndPackage.kt") + public void testNoAmbiguityBetweenRootAndPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/NoAmbiguityBetweenRootAndPackage.kt"); + doTest(fileName); + } + + @TestMetadata("sameClassNameResolve.kt") + public void testSameClassNameResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/sameClassNameResolve.kt"); + doTest(fileName); + } + + @TestMetadata("stopResolutionOnAmbiguity.kt") + public void testStopResolutionOnAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/stopResolutionOnAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/visibility.kt"); + doTest(fileName); + } + + @TestMetadata("visibility2.kt") + public void testVisibility2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/visibility2.kt"); + doTest(fileName); + } + + @TestMetadata("visibility3.kt") + public void testVisibility3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/visibility3.kt"); + doTest(fileName); + } + + @TestMetadata("VisibilityInClassObject.kt") + public void testVisibilityInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("VisibilityInheritModifier.kt") + public void testVisibilityInheritModifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/scopes/classHeader") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassHeader extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInClassHeader() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationOnClass.kt") + public void testAnnotationOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("annotationOnConstructors.kt") + public void testAnnotationOnConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("classGenericParameters.kt") + public void testClassGenericParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/classGenericParameters.kt"); + doTest(fileName); + } + + @TestMetadata("classParents.kt") + public void testClassParents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectParents.kt") + public void testCompanionObjectParents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectSuperConstructorArguments.kt") + public void testCompanionObjectSuperConstructorArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectSuperConstructorArguments.kt"); + doTest(fileName); + } + + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/constructors.kt"); + doTest(fileName); + } + + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/delegation.kt"); + doTest(fileName); + } + + @TestMetadata("objectParents.kt") + public void testObjectParents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt"); + doTest(fileName); + } + + @TestMetadata("objectSuperConstructorArguments.kt") + public void testObjectSuperConstructorArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/objectSuperConstructorArguments.kt"); + doTest(fileName); + } + + @TestMetadata("simpleDelegation.kt") + public void testSimpleDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/simpleDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("superConstructorArguments.kt") + public void testSuperConstructorArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArguments.kt"); + doTest(fileName); + } + + @TestMetadata("superConstructorArgumentsInSecondaryConstructor.kt") + public void testSuperConstructorArgumentsInSecondaryConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArgumentsInSecondaryConstructor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inheritance extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectAfterJava.kt") + public void testCompanionObjectAfterJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectsOrder.kt") + public void testCompanionObjectsOrder() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt"); + doTest(fileName); + } + + @TestMetadata("innerClasses.kt") + public void testInnerClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt"); + doTest(fileName); + } + + @TestMetadata("kt3856.kt") + public void testKt3856() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt"); + doTest(fileName); + } + + @TestMetadata("methodsPriority.kt") + public void testMethodsPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt"); + doTest(fileName); + } + + @TestMetadata("nestedClassesFromInterface.kt") + public void testNestedClassesFromInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt"); + doTest(fileName); + } + + @TestMetadata("nestedCompanionClass.kt") + public void testNestedCompanionClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt"); + doTest(fileName); + } + + @TestMetadata("nestedCompanionClassVsNested.kt") + public void testNestedCompanionClassVsNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt"); + doTest(fileName); + } + + @TestMetadata("nestedCompanionClassVsNestedJava.kt") + public void testNestedCompanionClassVsNestedJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt"); + doTest(fileName); + } + + @TestMetadata("nestedFromJava.kt") + public void testNestedFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("nestedFromJavaAfterKotlin.kt") + public void testNestedFromJavaAfterKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("nestedVsToplevelClass.kt") + public void testNestedVsToplevelClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt"); + doTest(fileName); + } + + @TestMetadata("severalCompanions.kt") + public void testSeveralCompanions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Statics extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInStatics() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("hidePrivateByPublic.kt") + public void testHidePrivateByPublic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.kt"); + doTest(fileName); + } + + @TestMetadata("jjkj.kt") + public void testJjkj() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/jjkj.kt"); + doTest(fileName); + } + + @TestMetadata("kjk.kt") + public void testKjk() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt"); + doTest(fileName); + } + + @TestMetadata("localVsStatic.kt") + public void testLocalVsStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt"); + doTest(fileName); + } + + @TestMetadata("nameClash0.kt") + public void testNameClash0() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.kt"); + doTest(fileName); + } + + @TestMetadata("nameClash1.kt") + public void testNameClash1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.kt"); + doTest(fileName); + } + + @TestMetadata("nameClash2.kt") + public void testNameClash2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.kt"); + doTest(fileName); + } + + @TestMetadata("oneInterfaceManyTimes.kt") + public void testOneInterfaceManyTimes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt"); + doTest(fileName); + } + + @TestMetadata("overloadStatic.kt") + public void testOverloadStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt"); + doTest(fileName); + } + + @TestMetadata("staticFunVsImport.kt") + public void testStaticFunVsImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt"); + doTest(fileName); + } + + @TestMetadata("staticPropertyVsImport.kt") + public void testStaticPropertyVsImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt"); + doTest(fileName); + } + + @TestMetadata("staticVsCompanion.kt") + public void testStaticVsCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("staticVsMember.kt") + public void testStaticVsMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt"); + doTest(fileName); + } + + @TestMetadata("staticVsOuter.kt") + public void testStaticVsOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt"); + doTest(fileName); + } + + @TestMetadata("staticsFromjava.kt") + public void testStaticsFromjava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt"); + doTest(fileName); + } + + @TestMetadata("staticsFromjavaAfterKotlin.kt") + public void testStaticsFromjavaAfterKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompanionObject extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accessToStaticMembersOfParentClass.kt") + public void testAccessToStaticMembersOfParentClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass.kt"); + doTest(fileName); + } + + @TestMetadata("accessToStaticMembersOfParentClassJKJ.kt") + public void testAccessToStaticMembersOfParentClassJKJ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInCompanionObject() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("inheritFromContainingClass.kt") + public void testInheritFromContainingClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass.kt"); + doTest(fileName); + } + + @TestMetadata("inheritFromJava.kt") + public void testInheritFromJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava.kt"); + doTest(fileName); + } + + @TestMetadata("inheritFromJavaAfterKotlin.kt") + public void testInheritFromJavaAfterKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin.kt"); + doTest(fileName); + } + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProtectedVisibility extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInProtectedVisibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("complexCompanion.kt") + public void testComplexCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.kt"); + doTest(fileName); + } + + @TestMetadata("constructorsInner.kt") + public void testConstructorsInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructorsInner.kt"); + doTest(fileName); + } + + @TestMetadata("innerClassInJava.kt") + public void testInnerClassInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.kt"); + doTest(fileName); + } + + @TestMetadata("innerProtectedClass.kt") + public void testInnerProtectedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerProtectedClass.kt"); + doTest(fileName); + } + + @TestMetadata("javaInheritedInKotlin.kt") + public void testJavaInheritedInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("kt7971.kt") + public void testKt7971() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt"); + doTest(fileName); + } + + @TestMetadata("nonSuperCallConstructor.kt") + public void testNonSuperCallConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("nonSuperCallConstructorJavaDifferentPackage.kt") + public void testNonSuperCallConstructorJavaDifferentPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt"); + doTest(fileName); + } + + @TestMetadata("nonSuperCallConstructorJavaSamePackage.kt") + public void testNonSuperCallConstructorJavaSamePackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt"); + doTest(fileName); + } + + @TestMetadata("protectedCallOnSubClass.kt") + public void testProtectedCallOnSubClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.kt"); + doTest(fileName); + } + + @TestMetadata("smartcastOnExtensionReceiver.kt") + public void testSmartcastOnExtensionReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/smartcastOnExtensionReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("syntheticPropertyExtensions.kt") + public void testSyntheticPropertyExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("syntheticSAMExtensions.kt") + public void testSyntheticSAMExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("unstableSmartCast.kt") + public void testUnstableSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("withSmartcast.kt") + public void testWithSmartcast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility/withSmartcast.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/script") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Script extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInScript() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("varInScript.kt") + public void testVarInScript() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/script/varInScript.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/sealed") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Sealed extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSealed() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DerivedTopLevel.kt") + public void testDerivedTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/DerivedTopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("DoubleInner.kt") + public void testDoubleInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/DoubleInner.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveOnRoot.kt") + public void testExhaustiveOnRoot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnRoot.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveOnTree.kt") + public void testExhaustiveOnTree() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnTree.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveOnTriangleStar.kt") + public void testExhaustiveOnTriangleStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnTriangleStar.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhen.kt") + public void testExhaustiveWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhen.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenDoubleInner.kt") + public void testExhaustiveWhenDoubleInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenDoubleInner.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenMultipleInner.kt") + public void testExhaustiveWhenMultipleInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenMultipleInner.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenNegated.kt") + public void testExhaustiveWhenNegated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenNegated.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenNegatedTwice.kt") + public void testExhaustiveWhenNegatedTwice() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenNegatedTwice.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenOnNestedSealed.kt") + public void testExhaustiveWhenOnNestedSealed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenOnNestedSealed.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenOnNullable.kt") + public void testExhaustiveWhenOnNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenOnNullable.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenWithAdditionalMember.kt") + public void testExhaustiveWhenWithAdditionalMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWhenWithElse.kt") + public void testExhaustiveWhenWithElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithElse.kt"); + doTest(fileName); + } + + @TestMetadata("Local.kt") + public void testLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/Local.kt"); + doTest(fileName); + } + + @TestMetadata("LocalSealed.kt") + public void testLocalSealed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/LocalSealed.kt"); + doTest(fileName); + } + + @TestMetadata("NestedSealed.kt") + public void testNestedSealed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NestedSealed.kt"); + doTest(fileName); + } + + @TestMetadata("NeverConstructed.kt") + public void testNeverConstructed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverConstructed.kt"); + doTest(fileName); + } + + @TestMetadata("NeverDerivedFromNested.kt") + public void testNeverDerivedFromNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverDerivedFromNested.kt"); + doTest(fileName); + } + + @TestMetadata("NeverEnum.kt") + public void testNeverEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverEnum.kt"); + doTest(fileName); + } + + @TestMetadata("NeverFinal.kt") + public void testNeverFinal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverFinal.kt"); + doTest(fileName); + } + + @TestMetadata("NeverInterface.kt") + public void testNeverInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverInterface.kt"); + doTest(fileName); + } + + @TestMetadata("NeverObject.kt") + public void testNeverObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverObject.kt"); + doTest(fileName); + } + + @TestMetadata("NeverOpen.kt") + public void testNeverOpen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NeverOpen.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWhen.kt") + public void testNonExhaustiveWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhen.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWhenNegated.kt") + public void testNonExhaustiveWhenNegated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenNegated.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWhenWithAdditionalCase.kt") + public void testNonExhaustiveWhenWithAdditionalCase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenWithAdditionalCase.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWhenWithAnyCase.kt") + public void testNonExhaustiveWhenWithAnyCase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenWithAnyCase.kt"); + doTest(fileName); + } + + @TestMetadata("NonPrivateConstructor.kt") + public void testNonPrivateConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NonPrivateConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("NotFinal.kt") + public void testNotFinal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/NotFinal.kt"); + doTest(fileName); + } + + @TestMetadata("OperationWhen.kt") + public void testOperationWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/OperationWhen.kt"); + doTest(fileName); + } + + @TestMetadata("RedundantAbstract.kt") + public void testRedundantAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("TreeWhen.kt") + public void testTreeWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/TreeWhen.kt"); + doTest(fileName); + } + + @TestMetadata("TreeWhenFunctional.kt") + public void testTreeWhenFunctional() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/TreeWhenFunctional.kt"); + doTest(fileName); + } + + @TestMetadata("TreeWhenFunctionalNoIs.kt") + public void testTreeWhenFunctionalNoIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/TreeWhenFunctionalNoIs.kt"); + doTest(fileName); + } + + @TestMetadata("WhenOnEmptySealed.kt") + public void testWhenOnEmptySealed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/WhenOnEmptySealed.kt"); + doTest(fileName); + } + + @TestMetadata("WithInterface.kt") + public void testWithInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sealed/WithInterface.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SecondaryConstructors extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSecondaryConstructors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("argumentsResolveInBodyAndDelegationCall.kt") + public void testArgumentsResolveInBodyAndDelegationCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.kt"); + doTest(fileName); + } + + @TestMetadata("classInitializersWithoutPrimary.kt") + public void testClassInitializersWithoutPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("companionObjectScope.kt") + public void testCompanionObjectScope() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/companionObjectScope.kt"); + doTest(fileName); + } + + @TestMetadata("constructorCallType.kt") + public void testConstructorCallType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt"); + doTest(fileName); + } + + @TestMetadata("constructorInObject.kt") + public void testConstructorInObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt"); + doTest(fileName); + } + + @TestMetadata("constructorInTrait.kt") + public void testConstructorInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/constructorInTrait.kt"); + doTest(fileName); + } + + @TestMetadata("ctrsAnnotationResolve.kt") + public void testCtrsAnnotationResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt"); + doTest(fileName); + } + + @TestMetadata("cyclicDelegationCalls.kt") + public void testCyclicDelegationCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/cyclicDelegationCalls.kt"); + doTest(fileName); + } + + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt"); + doTest(fileName); + } + + @TestMetadata("dataFlowInDelegationCall.kt") + public void testDataFlowInDelegationCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/dataFlowInDelegationCall.kt"); + doTest(fileName); + } + + @TestMetadata("delegationByWithoutPrimary.kt") + public void testDelegationByWithoutPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/delegationByWithoutPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/enums.kt"); + doTest(fileName); + } + + @TestMetadata("errorsOnEmptyDelegationCall.kt") + public void testErrorsOnEmptyDelegationCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt"); + doTest(fileName); + } + + @TestMetadata("expectedPrimaryConstructorCall.kt") + public void testExpectedPrimaryConstructorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/expectedPrimaryConstructorCall.kt"); + doTest(fileName); + } + + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/generics.kt"); + doTest(fileName); + } + + @TestMetadata("generics2.kt") + public void testGenerics2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt"); + doTest(fileName); + } + + @TestMetadata("generics3.kt") + public void testGenerics3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/generics3.kt"); + doTest(fileName); + } + + @TestMetadata("headerSupertypeInitialization.kt") + public void testHeaderSupertypeInitialization() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerSupertypeInitialization.kt"); + doTest(fileName); + } + + @TestMetadata("implicitSuperCallErrorsIfPrimary.kt") + public void testImplicitSuperCallErrorsIfPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("initializationFromOtherInstance.kt") + public void testInitializationFromOtherInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/initializationFromOtherInstance.kt"); + doTest(fileName); + } + + @TestMetadata("kt6992.kt") + public void testKt6992() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/kt6992.kt"); + doTest(fileName); + } + + @TestMetadata("kt6993.kt") + public void testKt6993() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt"); + doTest(fileName); + } + + @TestMetadata("kt6994.kt") + public void testKt6994() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaInDelegation.kt") + public void testLambdaInDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/lambdaInDelegation.kt"); + doTest(fileName); + } + + @TestMetadata("nestedExtendsInner.kt") + public void testNestedExtendsInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.kt"); + doTest(fileName); + } + + @TestMetadata("noDefaultIfEmptySecondary.kt") + public void testNoDefaultIfEmptySecondary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/noDefaultIfEmptySecondary.kt"); + doTest(fileName); + } + + @TestMetadata("noPrimaryConstructor.kt") + public void testNoPrimaryConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("noSupertypeInitWithSecondaryConstructors.kt") + public void testNoSupertypeInitWithSecondaryConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/noSupertypeInitWithSecondaryConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("propertyInitializationWithPrimary.kt") + public void testPropertyInitializationWithPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("propertyInitializationWithoutPrimary.kt") + public void testPropertyInitializationWithoutPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("redeclarations.kt") + public void testRedeclarations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt"); + doTest(fileName); + } + + @TestMetadata("redeclarationsOfConstructorsIgnored.kt") + public void testRedeclarationsOfConstructorsIgnored() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/redeclarationsOfConstructorsIgnored.kt"); + doTest(fileName); + } + + @TestMetadata("reportResolutionErrorOnImplicitOnce.kt") + public void testReportResolutionErrorOnImplicitOnce() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.kt"); + doTest(fileName); + } + + @TestMetadata("resolvePropertyInitializerWithoutPrimary.kt") + public void testResolvePropertyInitializerWithoutPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/resolvePropertyInitializerWithoutPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("return.kt") + public void testReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/return.kt"); + doTest(fileName); + } + + @TestMetadata("superAnyNonEmpty.kt") + public void testSuperAnyNonEmpty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt"); + doTest(fileName); + } + + @TestMetadata("superSecondaryNonExisting.kt") + public void testSuperSecondaryNonExisting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/superSecondaryNonExisting.kt"); + doTest(fileName); + } + + @TestMetadata("thisNonExisting.kt") + public void testThisNonExisting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/thisNonExisting.kt"); + doTest(fileName); + } + + @TestMetadata("unreachableCode.kt") + public void testUnreachableCode() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt"); + doTest(fileName); + } + + @TestMetadata("useOfPropertiesWithPrimary.kt") + public void testUseOfPropertiesWithPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("useOfPropertiesWithoutPrimary.kt") + public void testUseOfPropertiesWithoutPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("valOrValAndModifiersInCtr.kt") + public void testValOrValAndModifiersInCtr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt"); + doTest(fileName); + } + + @TestMetadata("varargsInDelegationCallToPrimary.kt") + public void testVarargsInDelegationCallToPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/varargsInDelegationCallToPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("varargsInDelegationCallToSecondary.kt") + public void testVarargsInDelegationCallToSecondary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/varargsInDelegationCallToSecondary.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class HeaderCallChecker extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accessBaseGenericFromInnerExtendingSameBase.kt") + public void testAccessBaseGenericFromInnerExtendingSameBase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.kt"); + doTest(fileName); + } + + @TestMetadata("accessBaseGenericFromInnerExtendingSameBase2.kt") + public void testAccessBaseGenericFromInnerExtendingSameBase2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase2.kt"); + doTest(fileName); + } + + @TestMetadata("accessBaseWithSameExtension.kt") + public void testAccessBaseWithSameExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseWithSameExtension.kt"); + doTest(fileName); + } + + @TestMetadata("accessGenericBaseWithSameExtension.kt") + public void testAccessGenericBaseWithSameExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInHeaderCallChecker() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("innerInstanceCreation.kt") + public void testInnerInstanceCreation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaAsArgument.kt") + public void testLambdaAsArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.kt"); + doTest(fileName); + } + + @TestMetadata("memberFunAccess.kt") + public void testMemberFunAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.kt"); + doTest(fileName); + } + + @TestMetadata("objectLiteralAsArgument.kt") + public void testObjectLiteralAsArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsArgument.kt"); + doTest(fileName); + } + + @TestMetadata("objectLiteralAsDefaultValueParameter.kt") + public void testObjectLiteralAsDefaultValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsDefaultValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("operatorCall.kt") + public void testOperatorCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.kt"); + doTest(fileName); + } + + @TestMetadata("passingInstance.kt") + public void testPassingInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/passingInstance.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAccess.kt") + public void testPropertyAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAccessUnitialized.kt") + public void testPropertyAccessUnitialized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.kt"); + doTest(fileName); + } + + @TestMetadata("superFunAccess.kt") + public void testSuperFunAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.kt"); + doTest(fileName); + } + + @TestMetadata("superFunAccessOverriden.kt") + public void testSuperFunAccessOverriden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.kt"); + doTest(fileName); + } + + @TestMetadata("superPropertyAccess.kt") + public void testSuperPropertyAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.kt"); + doTest(fileName); + } + + @TestMetadata("thisAsExtensionReceiver.kt") + public void testThisAsExtensionReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("usingOuterInstance.kt") + public void testUsingOuterInstance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterInstance.kt"); + doTest(fileName); + } + + @TestMetadata("usingOuterProperty.kt") + public void testUsingOuterProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterProperty.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/senselessComparison") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SenselessComparison extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSenselessComparison() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("noExplicitType.kt") + public void testNoExplicitType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/senselessComparison/noExplicitType.kt"); + doTest(fileName); + } + + @TestMetadata("parenthesized.kt") + public void testParenthesized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/senselessComparison/parenthesized.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/shadowing") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Shadowing extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInShadowing() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("noNameShadowingForSimpleParameters.kt") + public void testNoNameShadowingForSimpleParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/noNameShadowingForSimpleParameters.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowLambdaParameter.kt") + public void testShadowLambdaParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowLambdaParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowMultiDeclarationWithFunParameter.kt") + public void testShadowMultiDeclarationWithFunParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowParameterInFunctionBody.kt") + public void testShadowParameterInFunctionBody() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowParameterInFunctionBody.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowParameterInNestedBlockInFor.kt") + public void testShadowParameterInNestedBlockInFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowParameterInNestedBlockInFor.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowPropertyInClosure.kt") + public void testShadowPropertyInClosure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInClosure.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowPropertyInFor.kt") + public void testShadowPropertyInFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInFor.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowPropertyInFunction.kt") + public void testShadowPropertyInFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInFunction.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowVariableInFor.kt") + public void testShadowVariableInFor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInFor.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowVariableInNestedBlock.kt") + public void testShadowVariableInNestedBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedBlock.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowVariableInNestedClosure.kt") + public void testShadowVariableInNestedClosure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosure.kt"); + doTest(fileName); + } + + @TestMetadata("ShadowVariableInNestedClosureParam.kt") + public void testShadowVariableInNestedClosureParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosureParam.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SmartCasts extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("afterBinaryExpr.kt") + public void testAfterBinaryExpr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInSmartCasts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("alwaysNull.kt") + public void testAlwaysNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt"); + doTest(fileName); + } + + @TestMetadata("alwaysNullWithJava.kt") + public void testAlwaysNullWithJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectMember.kt") + public void testClassObjectMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/classObjectMember.kt"); + doTest(fileName); + } + + @TestMetadata("combineWithNoSelectorInfo.kt") + public void testCombineWithNoSelectorInfo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/combineWithNoSelectorInfo.kt"); + doTest(fileName); + } + + @TestMetadata("comparisonUnderAnd.kt") + public void testComparisonUnderAnd() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt"); + doTest(fileName); + } + + @TestMetadata("complexComparison.kt") + public void testComplexComparison() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt"); + doTest(fileName); + } + + @TestMetadata("complexConditionsWithExcl.kt") + public void testComplexConditionsWithExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/complexConditionsWithExcl.kt"); + doTest(fileName); + } + + @TestMetadata("dataFlowInfoForArguments.kt") + public void testDataFlowInfoForArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/dataFlowInfoForArguments.kt"); + doTest(fileName); + } + + @TestMetadata("doubleLambdaArgument.kt") + public void testDoubleLambdaArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/doubleLambdaArgument.kt"); + doTest(fileName); + } + + @TestMetadata("elvisExclExcl.kt") + public void testElvisExclExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/elvisExclExcl.kt"); + doTest(fileName); + } + + @TestMetadata("elvisExclExclMerge.kt") + public void testElvisExclExclMerge() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/elvisExclExclMerge.kt"); + doTest(fileName); + } + + @TestMetadata("elvisExclExclPlatform.kt") + public void testElvisExclExclPlatform() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.kt"); + doTest(fileName); + } + + @TestMetadata("elvisExprNotNull.kt") + public void testElvisExprNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("elvisNothingRHS.kt") + public void testElvisNothingRHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/elvisNothingRHS.kt"); + doTest(fileName); + } + + @TestMetadata("elvisRHS.kt") + public void testElvisRHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/elvisRHS.kt"); + doTest(fileName); + } + + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/equals.kt"); + doTest(fileName); + } + + @TestMetadata("exclUnderAnd.kt") + public void testExclUnderAnd() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/exclUnderAnd.kt"); + doTest(fileName); + } + + @TestMetadata("explicitDefaultGetter.kt") + public void testExplicitDefaultGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt"); + doTest(fileName); + } + + @TestMetadata("extensionSafeCall.kt") + public void testExtensionSafeCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/extensionSafeCall.kt"); + doTest(fileName); + } + + @TestMetadata("fakeSmartCastOnEquality.kt") + public void testFakeSmartCastOnEquality() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/fakeSmartCastOnEquality.kt"); + doTest(fileName); + } + + @TestMetadata("falseReceiverSmartCast.kt") + public void testFalseReceiverSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/falseReceiverSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("falseUnnecessaryCall.kt") + public void testFalseUnnecessaryCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/falseUnnecessaryCall.kt"); + doTest(fileName); + } + + @TestMetadata("fieldExclExcl.kt") + public void testFieldExclExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/fieldExclExcl.kt"); + doTest(fileName); + } + + @TestMetadata("fieldInGetter.kt") + public void testFieldInGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/fieldInGetter.kt"); + doTest(fileName); + } + + @TestMetadata("fieldPlus.kt") + public void testFieldPlus() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/fieldPlus.kt"); + doTest(fileName); + } + + @TestMetadata("genericIntersection.kt") + public void testGenericIntersection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/genericIntersection.kt"); + doTest(fileName); + } + + @TestMetadata("genericSet.kt") + public void testGenericSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/genericSet.kt"); + doTest(fileName); + } + + @TestMetadata("ifCascadeExprNotNull.kt") + public void testIfCascadeExprNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/ifCascadeExprNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("ifExprInConditionNonNull.kt") + public void testIfExprInConditionNonNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/ifExprInConditionNonNull.kt"); + doTest(fileName); + } + + @TestMetadata("ifExprInWhenSubjectNonNull.kt") + public void testIfExprInWhenSubjectNonNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/ifExprInWhenSubjectNonNull.kt"); + doTest(fileName); + } + + @TestMetadata("ifExprNonNull.kt") + public void testIfExprNonNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/ifExprNonNull.kt"); + doTest(fileName); + } + + @TestMetadata("ifWhenExprNonNull.kt") + public void testIfWhenExprNonNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/ifWhenExprNonNull.kt"); + doTest(fileName); + } + + @TestMetadata("implicitReceiver.kt") + public void testImplicitReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/implicitReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("implicitToGrandSon.kt") + public void testImplicitToGrandSon() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/implicitToGrandSon.kt"); + doTest(fileName); + } + + @TestMetadata("incDecToNull.kt") + public void testIncDecToNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/incDecToNull.kt"); + doTest(fileName); + } + + @TestMetadata("kt10232.kt") + public void testKt10232() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt10232.kt"); + doTest(fileName); + } + + @TestMetadata("kt10444.kt") + public void testKt10444() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt10444.kt"); + doTest(fileName); + } + + @TestMetadata("kt10483.kt") + public void testKt10483() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt10483.kt"); + doTest(fileName); + } + + @TestMetadata("kt1461.kt") + public void testKt1461() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt1461.kt"); + doTest(fileName); + } + + @TestMetadata("kt2422.kt") + public void testKt2422() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt2422.kt"); + doTest(fileName); + } + + @TestMetadata("kt2865.kt") + public void testKt2865() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt2865.kt"); + doTest(fileName); + } + + @TestMetadata("kt3224.kt") + public void testKt3224() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt3224.kt"); + doTest(fileName); + } + + @TestMetadata("kt3244.kt") + public void testKt3244() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt3244.kt"); + doTest(fileName); + } + + @TestMetadata("kt3572.kt") + public void testKt3572() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt3572.kt"); + doTest(fileName); + } + + @TestMetadata("kt3711.kt") + public void testKt3711() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt3711.kt"); + doTest(fileName); + } + + @TestMetadata("kt3899.kt") + public void testKt3899() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt3899.kt"); + doTest(fileName); + } + + @TestMetadata("kt3993.kt") + public void testKt3993() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt3993.kt"); + doTest(fileName); + } + + @TestMetadata("kt5427.kt") + public void testKt5427() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt5427.kt"); + doTest(fileName); + } + + @TestMetadata("kt5455.kt") + public void testKt5455() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt5455.kt"); + doTest(fileName); + } + + @TestMetadata("kt6819.kt") + public void testKt6819() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt6819.kt"); + doTest(fileName); + } + + @TestMetadata("kt7561.kt") + public void testKt7561() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/kt7561.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaAndArgument.kt") + public void testLambdaAndArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaAndArgumentFun.kt") + public void testLambdaAndArgumentFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentNoSubstitutedReturn.kt") + public void testLambdaArgumentNoSubstitutedReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentNoSubstitutedReturn.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentWithBoundWithoutType.kt") + public void testLambdaArgumentWithBoundWithoutType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentWithExpectedGenericType.kt") + public void testLambdaArgumentWithExpectedGenericType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithExpectedGenericType.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentWithoutType.kt") + public void testLambdaArgumentWithoutType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutType.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentWithoutTypeIf.kt") + public void testLambdaArgumentWithoutTypeIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeIf.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentWithoutTypeIfMerge.kt") + public void testLambdaArgumentWithoutTypeIfMerge() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeIfMerge.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaArgumentWithoutTypeWhen.kt") + public void testLambdaArgumentWithoutTypeWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeWhen.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaCall.kt") + public void testLambdaCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaCall.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaCallAnnotated.kt") + public void testLambdaCallAnnotated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaDeclaresAndModifies.kt") + public void testLambdaDeclaresAndModifies() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifies.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaDeclaresAndModifiesInLoop.kt") + public void testLambdaDeclaresAndModifiesInLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesInLoop.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaDeclaresAndModifiesInSecondary.kt") + public void testLambdaDeclaresAndModifiesInSecondary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesInSecondary.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaDeclaresAndModifiesWithDirectEq.kt") + public void testLambdaDeclaresAndModifiesWithDirectEq() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesWithDirectEq.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaUsesOwnerModifies.kt") + public void testLambdaUsesOwnerModifies() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/lambdaUsesOwnerModifies.kt"); + doTest(fileName); + } + + @TestMetadata("level_1_0.kt") + public void testLevel_1_0() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/level_1_0.kt"); + doTest(fileName); + } + + @TestMetadata("localClassChanges.kt") + public void testLocalClassChanges() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/localClassChanges.kt"); + doTest(fileName); + } + + @TestMetadata("localFunBetween.kt") + public void testLocalFunBetween() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/localFunBetween.kt"); + doTest(fileName); + } + + @TestMetadata("localFunChanges.kt") + public void testLocalFunChanges() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt"); + doTest(fileName); + } + + @TestMetadata("localObjectChanges.kt") + public void testLocalObjectChanges() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/localObjectChanges.kt"); + doTest(fileName); + } + + @TestMetadata("multipleResolvedCalls.kt") + public void testMultipleResolvedCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/multipleResolvedCalls.kt"); + doTest(fileName); + } + + @TestMetadata("noErrorCheckForPackageLevelVal.kt") + public void testNoErrorCheckForPackageLevelVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt"); + doTest(fileName); + } + + @TestMetadata("noUnnecessarySmartCastForReceiver.kt") + public void testNoUnnecessarySmartCastForReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/noUnnecessarySmartCastForReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("notNullorNotNull.kt") + public void testNotNullorNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/notNullorNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("openInSealed.kt") + public void testOpenInSealed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt"); + doTest(fileName); + } + + @TestMetadata("ownerDeclaresBothModifies.kt") + public void testOwnerDeclaresBothModifies() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/ownerDeclaresBothModifies.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAsCondition.kt") + public void testPropertyAsCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/propertyAsCondition.kt"); + doTest(fileName); + } + + @TestMetadata("propertyToNotNull.kt") + public void testPropertyToNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("safeAs.kt") + public void testSafeAs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safeAs.kt"); + doTest(fileName); + } + + @TestMetadata("shortIfExprNotNull.kt") + public void testShortIfExprNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/shortIfExprNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastAndArgumentApproximation.kt") + public void testSmartCastAndArgumentApproximation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/smartCastAndArgumentApproximation.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastOnElvis.kt") + public void testSmartCastOnElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/smartCastOnElvis.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastOnIf.kt") + public void testSmartCastOnIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/smartCastOnIf.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastOnWhen.kt") + public void testSmartCastOnWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/smartCastOnWhen.kt"); + doTest(fileName); + } + + @TestMetadata("thisWithLabel.kt") + public void testThisWithLabel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt"); + doTest(fileName); + } + + @TestMetadata("thisWithLabelAsReceiverPart.kt") + public void testThisWithLabelAsReceiverPart() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt"); + doTest(fileName); + } + + @TestMetadata("threeImplicitReceivers.kt") + public void testThreeImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/threeImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("twoImplicitReceivers.kt") + public void testTwoImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/twoImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("typeDegradation.kt") + public void testTypeDegradation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/typeDegradation.kt"); + doTest(fileName); + } + + @TestMetadata("typeInComparison.kt") + public void testTypeInComparison() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/typeInComparison.kt"); + doTest(fileName); + } + + @TestMetadata("unstableToStable.kt") + public void testUnstableToStable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt"); + doTest(fileName); + } + + @TestMetadata("unstableToStableTypes.kt") + public void testUnstableToStableTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt"); + doTest(fileName); + } + + @TestMetadata("varChangedInInitializer.kt") + public void testVarChangedInInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("varChangedInLocalInitializer.kt") + public void testVarChangedInLocalInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varChangedInLocalInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("varInAccessor.kt") + public void testVarInAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varInAccessor.kt"); + doTest(fileName); + } + + @TestMetadata("varInInitNoPrimary.kt") + public void testVarInInitNoPrimary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt"); + doTest(fileName); + } + + @TestMetadata("varInInitializer.kt") + public void testVarInInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("varInSecondaryConstructor.kt") + public void testVarInSecondaryConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varInSecondaryConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("varInsideLocalFun.kt") + public void testVarInsideLocalFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.kt"); + doTest(fileName); + } + + @TestMetadata("whenExprNonNull.kt") + public void testWhenExprNonNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/whenExprNonNull.kt"); + doTest(fileName); + } + + @TestMetadata("whenIfExprNonNull.kt") + public void testWhenIfExprNonNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/whenIfExprNonNull.kt"); + doTest(fileName); + } + + @TestMetadata("whenSubjectImpossible.kt") + public void testWhenSubjectImpossible() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/whenSubjectImpossible.kt"); + doTest(fileName); + } + + @TestMetadata("whenSubjectImpossibleJava.kt") + public void testWhenSubjectImpossibleJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/whenSubjectImpossibleJava.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/inference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inference extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("dependentOnPrevArg.kt") + public void testDependentOnPrevArg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/dependentOnPrevArg.kt"); + doTest(fileName); + } + + @TestMetadata("intersectionTypes.kt") + public void testIntersectionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("kt1275.kt") + public void testKt1275() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt"); + doTest(fileName); + } + + @TestMetadata("kt1355.kt") + public void testKt1355() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.kt"); + doTest(fileName); + } + + @TestMetadata("kt2746.kt") + public void testKt2746() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt2746.kt"); + doTest(fileName); + } + + @TestMetadata("kt2851.kt") + public void testKt2851() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt2851.kt"); + doTest(fileName); + } + + @TestMetadata("kt4009.kt") + public void testKt4009() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt4009.kt"); + doTest(fileName); + } + + @TestMetadata("kt4403.kt") + public void testKt4403() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt4403.kt"); + doTest(fileName); + } + + @TestMetadata("kt4415.kt") + public void testKt4415() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt4415.kt"); + doTest(fileName); + } + + @TestMetadata("kt6242.kt") + public void testKt6242() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.kt"); + doTest(fileName); + } + + @TestMetadata("smartCastOnReceiver.kt") + public void testSmartCastOnReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/inference/smartCastOnReceiver.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IntersectionScope extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInIntersectionScope() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("conflictTypeParameters.kt") + public void testConflictTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingReturnType.kt") + public void testConflictingReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictingReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("flexibleTypes.kt") + public void testFlexibleTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt"); + doTest(fileName); + } + + @TestMetadata("moreSpecificSetter.kt") + public void testMoreSpecificSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/moreSpecificSetter.kt"); + doTest(fileName); + } + + @TestMetadata("moreSpecificVisibility.kt") + public void testMoreSpecificVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/moreSpecificVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("mostSpecific.kt") + public void testMostSpecific() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecific.kt"); + doTest(fileName); + } + + @TestMetadata("mostSpecificIrrelevant.kt") + public void testMostSpecificIrrelevant() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecificIrrelevant.kt"); + doTest(fileName); + } + + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/properties.kt"); + doTest(fileName); + } + + @TestMetadata("propertiesConflict.kt") + public void testPropertiesConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/propertiesConflict.kt"); + doTest(fileName); + } + + @TestMetadata("refineReturnType.kt") + public void testRefineReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/refineReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/simple.kt"); + doTest(fileName); + } + + @TestMetadata("unstableSmartCast.kt") + public void testUnstableSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("validTypeParameters.kt") + public void testValidTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("validTypeParametersNoSmartCast.kt") + public void testValidTypeParametersNoSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParametersNoSmartCast.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/loops") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Loops extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInLoops() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignElvisIfBreakInsideWhileTrue.kt") + public void testAssignElvisIfBreakInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/assignElvisIfBreakInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("assignWhenInsideWhileTrue.kt") + public void testAssignWhenInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/assignWhenInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("callBreakBetweenInsideDoWhile.kt") + public void testCallBreakBetweenInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakBetweenInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("callBreakFirstInsideDoWhile.kt") + public void testCallBreakFirstInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakFirstInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("callBreakInsideDoWhile.kt") + public void testCallBreakInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("callBreakSecondInsideDoWhile.kt") + public void testCallBreakSecondInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakSecondInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("callBreakThirdInsideDoWhile.kt") + public void testCallBreakThirdInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakThirdInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("doWhile.kt") + public void testDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhile.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileBreak.kt") + public void testDoWhileBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileBreak.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileContinue.kt") + public void testDoWhileContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileContinue.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileEarlyBreak.kt") + public void testDoWhileEarlyBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileEarlyBreak.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileEarlyContinue.kt") + public void testDoWhileEarlyContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileEarlyContinue.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileInCondition.kt") + public void testDoWhileInCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileInCondition.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileInConditionWithBreak.kt") + public void testDoWhileInConditionWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileInConditionWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileLiteral.kt") + public void testDoWhileLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileNotNullBreak.kt") + public void testDoWhileNotNullBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNotNullBreak.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileNull.kt") + public void testDoWhileNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNull.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileNullWithBreak.kt") + public void testDoWhileNullWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNullWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("elvisBreakInsideDoWhile.kt") + public void testElvisBreakInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/elvisBreakInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("elvisIfBreakInsideWhileTrue.kt") + public void testElvisIfBreakInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/elvisIfBreakInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("elvisInsideDoWhile.kt") + public void testElvisInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/elvisInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("elvisLeftBreakInsideWhileTrue.kt") + public void testElvisLeftBreakInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/elvisLeftBreakInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("ifBlockInsideDoWhile.kt") + public void testIfBlockInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/ifBlockInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("ifBreakAssignInsideDoWhile.kt") + public void testIfBreakAssignInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakAssignInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("ifBreakAssignInsideWhileTrue.kt") + public void testIfBreakAssignInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakAssignInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("ifBreakExprInsideWhileTrue.kt") + public void testIfBreakExprInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakExprInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("ifElseBlockInsideDoWhile.kt") + public void testIfElseBlockInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/ifElseBlockInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("ifInsideDoWhile.kt") + public void testIfInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/ifInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("leftElvisBreakInsideWhileTrue.kt") + public void testLeftElvisBreakInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/leftElvisBreakInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("nestedDoWhile.kt") + public void testNestedDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("nestedDoWhileWithLongContinue.kt") + public void testNestedDoWhileWithLongContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedDoWhileWithLongContinue.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLoops.kt") + public void testNestedLoops() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoops.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLoopsShort.kt") + public void testNestedLoopsShort() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsShort.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLoopsWithBreak.kt") + public void testNestedLoopsWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLoopsWithLongBreak.kt") + public void testNestedLoopsWithLongBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithLongBreak.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLoopsWithLongContinue.kt") + public void testNestedLoopsWithLongContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithLongContinue.kt"); + doTest(fileName); + } + + @TestMetadata("plusAssignWhenInsideDoWhile.kt") + public void testPlusAssignWhenInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/plusAssignWhenInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("safeCallBreakInsideDoWhile.kt") + public void testSafeCallBreakInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/safeCallBreakInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("safeCallInsideDoWhile.kt") + public void testSafeCallInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/safeCallInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("useInsideDoWhile.kt") + public void testUseInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/useInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("whenInsideWhileTrue.kt") + public void testWhenInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whenInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("whenReturnInsideWhileTrue.kt") + public void testWhenReturnInsideWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whenReturnInsideWhileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("whileInCondition.kt") + public void testWhileInCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileInCondition.kt"); + doTest(fileName); + } + + @TestMetadata("whileInConditionWithBreak.kt") + public void testWhileInConditionWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileInConditionWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("whileNull.kt") + public void testWhileNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileNull.kt"); + doTest(fileName); + } + + @TestMetadata("whileNullWithBreak.kt") + public void testWhileNullWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileNullWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("whileSimple.kt") + public void testWhileSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileSimple.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrivial.kt") + public void testWhileTrivial() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrivial.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrue.kt") + public void testWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrueBreakReturn.kt") + public void testWhileTrueBreakReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueBreakReturn.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrueEarlyBreak.kt") + public void testWhileTrueEarlyBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueEarlyBreak.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrueReturn.kt") + public void testWhileTrueReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueReturn.kt"); + doTest(fileName); + } + + @TestMetadata("WhileTrueWithBreakInIfCondition.kt") + public void testWhileTrueWithBreakInIfCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/loops/WhileTrueWithBreakInIfCondition.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ObjectLiterals extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInObjectLiterals() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("base.kt") + public void testBase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/base.kt"); + doTest(fileName); + } + + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt"); + doTest(fileName); + } + + @TestMetadata("exclexcl.kt") + public void testExclexcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexcl.kt"); + doTest(fileName); + } + + @TestMetadata("exclexclArgument.kt") + public void testExclexclArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexclArgument.kt"); + doTest(fileName); + } + + @TestMetadata("exclexclTwoArgument.kt") + public void testExclexclTwoArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexclTwoArgument.kt"); + doTest(fileName); + } + + @TestMetadata("kt7110.kt") + public void testKt7110() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/kt7110.kt"); + doTest(fileName); + } + + @TestMetadata("receiver.kt") + public void testReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/receiver.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PublicVals extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInPublicVals() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("customGetter.kt") + public void testCustomGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/customGetter.kt"); + doTest(fileName); + } + + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/delegate.kt"); + doTest(fileName); + } + + @TestMetadata("kt4409.kt") + public void testKt4409() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/kt4409.kt"); + doTest(fileName); + } + + @TestMetadata("kt5502.kt") + public void testKt5502() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/kt5502.kt"); + doTest(fileName); + } + + @TestMetadata("open.kt") + public void testOpen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/open.kt"); + doTest(fileName); + } + + @TestMetadata("otherModule.kt") + public void testOtherModule() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.kt"); + doTest(fileName); + } + + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/protected.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/simple.kt"); + doTest(fileName); + } + + @TestMetadata("var.kt") + public void testVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals/var.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Safecalls extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSafecalls() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("anotherVal.kt") + public void testAnotherVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt"); + doTest(fileName); + } + + @TestMetadata("argument.kt") + public void testArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/argument.kt"); + doTest(fileName); + } + + @TestMetadata("chainAndUse.kt") + public void testChainAndUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainAndUse.kt"); + doTest(fileName); + } + + @TestMetadata("chainInChain.kt") + public void testChainInChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainInChain.kt"); + doTest(fileName); + } + + @TestMetadata("chainMixedUnsafe.kt") + public void testChainMixedUnsafe() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainMixedUnsafe.kt"); + doTest(fileName); + } + + @TestMetadata("doubleCall.kt") + public void testDoubleCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/doubleCall.kt"); + doTest(fileName); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/extension.kt"); + doTest(fileName); + } + + @TestMetadata("extensionCall.kt") + public void testExtensionCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/extensionCall.kt"); + doTest(fileName); + } + + @TestMetadata("falseArgument.kt") + public void testFalseArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseArgument.kt"); + doTest(fileName); + } + + @TestMetadata("falseChain.kt") + public void testFalseChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseChain.kt"); + doTest(fileName); + } + + @TestMetadata("falseExtension.kt") + public void testFalseExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseExtension.kt"); + doTest(fileName); + } + + @TestMetadata("falseSecondArgument.kt") + public void testFalseSecondArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt"); + doTest(fileName); + } + + @TestMetadata("innerReceiver.kt") + public void testInnerReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/innerReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("insideCall.kt") + public void testInsideCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/insideCall.kt"); + doTest(fileName); + } + + @TestMetadata("insideIfExpr.kt") + public void testInsideIfExpr() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/insideIfExpr.kt"); + doTest(fileName); + } + + @TestMetadata("longChain.kt") + public void testLongChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/longChain.kt"); + doTest(fileName); + } + + @TestMetadata("nullableReceiver.kt") + public void testNullableReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("nullableReceiverInLongChain.kt") + public void testNullableReceiverInLongChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverInLongChain.kt"); + doTest(fileName); + } + + @TestMetadata("nullableReceiverWithExclExcl.kt") + public void testNullableReceiverWithExclExcl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverWithExclExcl.kt"); + doTest(fileName); + } + + @TestMetadata("nullableReceiverWithFlexible.kt") + public void testNullableReceiverWithFlexible() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverWithFlexible.kt"); + doTest(fileName); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/property.kt"); + doTest(fileName); + } + + @TestMetadata("propertyChain.kt") + public void testPropertyChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/propertyChain.kt"); + doTest(fileName); + } + + @TestMetadata("receiver.kt") + public void testReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiver.kt"); + doTest(fileName); + } + + @TestMetadata("receiverAndChain.kt") + public void testReceiverAndChain() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChain.kt"); + doTest(fileName); + } + + @TestMetadata("receiverAndChainFalse.kt") + public void testReceiverAndChainFalse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt"); + doTest(fileName); + } + + @TestMetadata("safeAccessReceiverNotNull.kt") + public void testSafeAccessReceiverNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/safeAccessReceiverNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/simple.kt"); + doTest(fileName); + } + + @TestMetadata("simpleNullableReceiver.kt") + public void testSimpleNullableReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("twoArgs.kt") + public void testTwoArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls/twoArgs.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/variables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Variables extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("accessorAndFunction.kt") + public void testAccessorAndFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/accessorAndFunction.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInVariables() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("assignmentConversion.kt") + public void testAssignmentConversion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/assignmentConversion.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileWithMiddleBreak.kt") + public void testDoWhileWithMiddleBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/doWhileWithMiddleBreak.kt"); + doTest(fileName); + } + + @TestMetadata("ifElseBlockInsideDoWhile.kt") + public void testIfElseBlockInsideDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/ifElseBlockInsideDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("ifElseBlockInsideDoWhileWithBreak.kt") + public void testIfElseBlockInsideDoWhileWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/ifElseBlockInsideDoWhileWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("ifNullAssignment.kt") + public void testIfNullAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarIs.kt") + public void testIfVarIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIs.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarIsAnd.kt") + public void testIfVarIsAnd() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsAnd.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarIsChanged.kt") + public void testIfVarIsChanged() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.kt"); + doTest(fileName); + } + + @TestMetadata("inPropertySam.kt") + public void testInPropertySam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/inPropertySam.kt"); + doTest(fileName); + } + + @TestMetadata("infix.kt") + public void testInfix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/infix.kt"); + doTest(fileName); + } + + @TestMetadata("initialization.kt") + public void testInitialization() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/initialization.kt"); + doTest(fileName); + } + + @TestMetadata("kt7599.kt") + public void testKt7599() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/kt7599.kt"); + doTest(fileName); + } + + @TestMetadata("lambdaBetweenArguments.kt") + public void testLambdaBetweenArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt"); + doTest(fileName); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/property.kt"); + doTest(fileName); + } + + @TestMetadata("propertyNotNeeded.kt") + public void testPropertyNotNeeded() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/propertyNotNeeded.kt"); + doTest(fileName); + } + + @TestMetadata("propertySubtype.kt") + public void testPropertySubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtype.kt"); + doTest(fileName); + } + + @TestMetadata("propertySubtypeInMember.kt") + public void testPropertySubtypeInMember() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtypeInMember.kt"); + doTest(fileName); + } + + @TestMetadata("propertySubtypeInMemberCheck.kt") + public void testPropertySubtypeInMemberCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtypeInMemberCheck.kt"); + doTest(fileName); + } + + @TestMetadata("varAsUse.kt") + public void testVarAsUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/varAsUse.kt"); + doTest(fileName); + } + + @TestMetadata("varChangedInLoop.kt") + public void testVarChangedInLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/varChangedInLoop.kt"); + doTest(fileName); + } + + @TestMetadata("varNotChangedInLoop.kt") + public void testVarNotChangedInLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/varNotChangedInLoop.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrue.kt") + public void testWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/whileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("whileWithBreak.kt") + public void testWhileWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/variables/whileWithBreak.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Varnotnull extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInVarnotnull() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("assignNestedWhile.kt") + public void testAssignNestedWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignNestedWhile.kt"); + doTest(fileName); + } + + @TestMetadata("assignment.kt") + public void testAssignment() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt"); + doTest(fileName); + } + + @TestMetadata("boundInitializer.kt") + public void testBoundInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("boundInitializerWrong.kt") + public void testBoundInitializerWrong() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileWithBreak.kt") + public void testDoWhileWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("doWhileWithMiddleBreak.kt") + public void testDoWhileWithMiddleBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithMiddleBreak.kt"); + doTest(fileName); + } + + @TestMetadata("forEach.kt") + public void testForEach() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt"); + doTest(fileName); + } + + @TestMetadata("forEachWithBreak.kt") + public void testForEachWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("forEachWithContinue.kt") + public void testForEachWithContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarNotNull.kt") + public void testIfVarNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarNotNullAnd.kt") + public void testIfVarNotNullAnd() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNotNullAnd.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarNullElse.kt") + public void testIfVarNullElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNullElse.kt"); + doTest(fileName); + } + + @TestMetadata("ifVarNullReturn.kt") + public void testIfVarNullReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNullReturn.kt"); + doTest(fileName); + } + + @TestMetadata("inference.kt") + public void testInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/inference.kt"); + doTest(fileName); + } + + @TestMetadata("infiniteWhileWithBreak.kt") + public void testInfiniteWhileWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.kt"); + doTest(fileName); + } + + @TestMetadata("infix.kt") + public void testInfix() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/infix.kt"); + doTest(fileName); + } + + @TestMetadata("initInTryReturnInCatch.kt") + public void testInitInTryReturnInCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt"); + doTest(fileName); + } + + @TestMetadata("initialization.kt") + public void testInitialization() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt"); + doTest(fileName); + } + + @TestMetadata("iterations.kt") + public void testIterations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.kt"); + doTest(fileName); + } + + @TestMetadata("nestedDoWhile.kt") + public void testNestedDoWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedDoWhile.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLoops.kt") + public void testNestedLoops() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedLoops.kt"); + doTest(fileName); + } + + @TestMetadata("nestedWhile.kt") + public void testNestedWhile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedWhile.kt"); + doTest(fileName); + } + + @TestMetadata("plusplusMinusminus.kt") + public void testPlusplusMinusminus() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt"); + doTest(fileName); + } + + @TestMetadata("postfixNotnullClassIncrement.kt") + public void testPostfixNotnullClassIncrement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt"); + doTest(fileName); + } + + @TestMetadata("postfixNullableClassIncrement.kt") + public void testPostfixNullableClassIncrement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNullableClassIncrement.kt"); + doTest(fileName); + } + + @TestMetadata("postfixNullableIncrement.kt") + public void testPostfixNullableIncrement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNullableIncrement.kt"); + doTest(fileName); + } + + @TestMetadata("prefixNotnullClassIncrement.kt") + public void testPrefixNotnullClassIncrement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt"); + doTest(fileName); + } + + @TestMetadata("prefixNullableClassIncrement.kt") + public void testPrefixNullableClassIncrement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNullableClassIncrement.kt"); + doTest(fileName); + } + + @TestMetadata("prefixNullableIncrement.kt") + public void testPrefixNullableIncrement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNullableIncrement.kt"); + doTest(fileName); + } + + @TestMetadata("setNotNullInTry.kt") + public void testSetNotNullInTry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNotNullInTry.kt"); + doTest(fileName); + } + + @TestMetadata("setNullInTry.kt") + public void testSetNullInTry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTry.kt"); + doTest(fileName); + } + + @TestMetadata("setNullInTryFinally.kt") + public void testSetNullInTryFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTryFinally.kt"); + doTest(fileName); + } + + @TestMetadata("setNullInTryUnsound.kt") + public void testSetNullInTryUnsound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTryUnsound.kt"); + doTest(fileName); + } + + @TestMetadata("setSameInTry.kt") + public void testSetSameInTry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setSameInTry.kt"); + doTest(fileName); + } + + @TestMetadata("toFlexibleType.kt") + public void testToFlexibleType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/toFlexibleType.kt"); + doTest(fileName); + } + + @TestMetadata("unnecessary.kt") + public void testUnnecessary() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessary.kt"); + doTest(fileName); + } + + @TestMetadata("unnecessaryWithBranch.kt") + public void testUnnecessaryWithBranch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithBranch.kt"); + doTest(fileName); + } + + @TestMetadata("unnecessaryWithMap.kt") + public void testUnnecessaryWithMap() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt"); + doTest(fileName); + } + + @TestMetadata("varCapturedInClosure.kt") + public void testVarCapturedInClosure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInClosure.kt"); + doTest(fileName); + } + + @TestMetadata("varCapturedInInlineClosure.kt") + public void testVarCapturedInInlineClosure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt"); + doTest(fileName); + } + + @TestMetadata("varCapturedInSafeClosure.kt") + public void testVarCapturedInSafeClosure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInSafeClosure.kt"); + doTest(fileName); + } + + @TestMetadata("varChangedInLoop.kt") + public void testVarChangedInLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varChangedInLoop.kt"); + doTest(fileName); + } + + @TestMetadata("varCheck.kt") + public void testVarCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCheck.kt"); + doTest(fileName); + } + + @TestMetadata("varIntNull.kt") + public void testVarIntNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt"); + doTest(fileName); + } + + @TestMetadata("varNotChangedInLoop.kt") + public void testVarNotChangedInLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNotChangedInLoop.kt"); + doTest(fileName); + } + + @TestMetadata("varNull.kt") + public void testVarNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrue.kt") + public void testWhileTrue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrue.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrueWithBracketSet.kt") + public void testWhileTrueWithBracketSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrueWithBracketSet.kt"); + doTest(fileName); + } + + @TestMetadata("whileTrueWithBrackets.kt") + public void testWhileTrueWithBrackets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrueWithBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("whileWithBreak.kt") + public void testWhileWithBreak() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SourceCompatibility extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSourceCompatibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("inlineFunctionAlways.kt") + public void testInlineFunctionAlways() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/inlineFunctionAlways.kt"); + doTest(fileName); + } + + @TestMetadata("noDataClassInheritance.kt") + public void testNoDataClassInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noDataClassInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("noInlineProperty.kt") + public void testNoInlineProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noInlineProperty.kt"); + doTest(fileName); + } + + @TestMetadata("noLocalDelegatedProperty.kt") + public void testNoLocalDelegatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noLocalDelegatedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("noLocalDelegatedPropertyInScript.kt") + public void testNoLocalDelegatedPropertyInScript() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noLocalDelegatedPropertyInScript.kt"); + doTest(fileName); + } + + @TestMetadata("noMultiplatformProjects.kt") + public void testNoMultiplatformProjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt"); + doTest(fileName); + } + + @TestMetadata("noTopLevelSealedInheritance.kt") + public void testNoTopLevelSealedInheritance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noTopLevelSealedInheritance.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ApiVersion extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInApiVersion() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt"); + doTest(fileName); + } + + @TestMetadata("classesAndConstructors.kt") + public void testClassesAndConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("overriddenMembers.kt") + public void testOverriddenMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/overriddenMembers.kt"); + doTest(fileName); + } + + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/propertyAccessors.kt"); + doTest(fileName); + } + + @TestMetadata("simpleMembers.kt") + public void testSimpleMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/simpleMembers.kt"); + doTest(fileName); + } + + @TestMetadata("sinceOldVersionIsOK.kt") + public void testSinceOldVersionIsOK() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/sinceOldVersionIsOK.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasesAsCompanionObjects.kt") + public void testTypealiasesAsCompanionObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasesAsConstructors.kt") + public void testTypealiasesAsConstructors() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasesAsObjects.kt") + public void testTypealiasesAsObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsObjects.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasesAsTypes.kt") + public void testTypealiasesAsTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsTypes.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasesOnImport.kt") + public void testTypealiasesOnImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesOnImport.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NoBoundCallableReferences extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInNoBoundCallableReferences() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("boundCallableReference.kt") + public void testBoundCallableReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/boundCallableReference.kt"); + doTest(fileName); + } + + @TestMetadata("boundClassLiteral.kt") + public void testBoundClassLiteral() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/boundClassLiteral.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedJavaClassLiteralInKClassExtension.kt") + public void testQualifiedJavaClassLiteralInKClassExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/qualifiedJavaClassLiteralInKClassExtension.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedJavaClassReferenceInKClassExtension.kt") + public void testQualifiedJavaClassReferenceInKClassExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/qualifiedJavaClassReferenceInKClassExtension.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/substitutions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Substitutions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSubstitutions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt1558-short.kt") + public void testKt1558_short() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/substitutions/kt1558-short.kt"); + doTest(fileName); + } + + @TestMetadata("kt4887.kt") + public void testKt4887() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/substitutions/kt4887.kt"); + doTest(fileName); + } + + @TestMetadata("starProjections.kt") + public void testStarProjections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/substitutions/starProjections.kt"); + doTest(fileName); + } + + @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt") + public void testUpperBoundsSubstitutionForOverloadResolutionWithAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt") + public void testUpperBoundsSubstitutionForOverloadResolutionWithErrorTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/subtyping") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Subtyping extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSubtyping() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("extFunctionTypeAsSuperType.kt") + public void testExtFunctionTypeAsSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/extFunctionTypeAsSuperType.kt"); + doTest(fileName); + } + + @TestMetadata("findClosestCorrespondingSupertype.kt") + public void testFindClosestCorrespondingSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("functionTypeAsSuperType.kt") + public void testFunctionTypeAsSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/functionTypeAsSuperType.kt"); + doTest(fileName); + } + + @TestMetadata("invariantArgumentForTypeParameterWithMultipleBounds.kt") + public void testInvariantArgumentForTypeParameterWithMultipleBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/invariantArgumentForTypeParameterWithMultipleBounds.kt"); + doTest(fileName); + } + + @TestMetadata("javaAndKotlinSuperType.kt") + public void testJavaAndKotlinSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.kt"); + doTest(fileName); + } + + @TestMetadata("kt2069.kt") + public void testKt2069() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/kt2069.kt"); + doTest(fileName); + } + + @TestMetadata("kt2744.kt") + public void testKt2744() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/kt2744.kt"); + doTest(fileName); + } + + @TestMetadata("kt304.kt") + public void testKt304() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/kt304.kt"); + doTest(fileName); + } + + @TestMetadata("kt3159.kt") + public void testKt3159() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/kt3159.kt"); + doTest(fileName); + } + + @TestMetadata("kt-1457.kt") + public void testKt_1457() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/kt-1457.kt"); + doTest(fileName); + } + + @TestMetadata("localAnonymousObjects.kt") + public void testLocalAnonymousObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/localAnonymousObjects.kt"); + doTest(fileName); + } + + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/localClasses.kt"); + doTest(fileName); + } + + @TestMetadata("memberAnonymousObjects.kt") + public void testMemberAnonymousObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt"); + doTest(fileName); + } + + @TestMetadata("nestedIntoLocalClasses.kt") + public void testNestedIntoLocalClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt"); + doTest(fileName); + } + + @TestMetadata("nestedLocalClasses.kt") + public void testNestedLocalClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelAnonymousObjects.kt") + public void testTopLevelAnonymousObjects() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/topLevelAnonymousObjects.kt"); + doTest(fileName); + } + + @TestMetadata("unresolvedSupertype.kt") + public void testUnresolvedSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/subtyping/unresolvedSupertype.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/suppress") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Suppress extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSuppress() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AllWarnings extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInAllWarnings() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("suppressWarningsOnAnonymousObjectInVariable.kt") + public void testSuppressWarningsOnAnonymousObjectInVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnAnonymousObjectInVariable.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnClass.kt") + public void testSuppressWarningsOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnClassObject.kt") + public void testSuppressWarningsOnClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnExpression.kt") + public void testSuppressWarningsOnExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnExpression.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnFile.kt") + public void testSuppressWarningsOnFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnFile.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnFunction.kt") + public void testSuppressWarningsOnFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnFunction.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnObject.kt") + public void testSuppressWarningsOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnParameter.kt") + public void testSuppressWarningsOnParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnParameter.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnProperty.kt") + public void testSuppressWarningsOnProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnProperty.kt"); + doTest(fileName); + } + + @TestMetadata("suppressWarningsOnPropertyAccessor.kt") + public void testSuppressWarningsOnPropertyAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnPropertyAccessor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ManyWarnings extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInManyWarnings() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("mixed.kt") + public void testMixed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/mixed.kt"); + doTest(fileName); + } + + @TestMetadata("onClass.kt") + public void testOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onClass.kt"); + doTest(fileName); + } + + @TestMetadata("onClassObject.kt") + public void testOnClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("onExpression.kt") + public void testOnExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onExpression.kt"); + doTest(fileName); + } + + @TestMetadata("onFunction.kt") + public void testOnFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onFunction.kt"); + doTest(fileName); + } + + @TestMetadata("onObject.kt") + public void testOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onObject.kt"); + doTest(fileName); + } + + @TestMetadata("onParameter.kt") + public void testOnParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onParameter.kt"); + doTest(fileName); + } + + @TestMetadata("onProperty.kt") + public void testOnProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onProperty.kt"); + doTest(fileName); + } + + @TestMetadata("onPropertyAccessor.kt") + public void testOnPropertyAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings/onPropertyAccessor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OneWarning extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOneWarning() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("onBlockStatement.kt") + public void testOnBlockStatement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onBlockStatement.kt"); + doTest(fileName); + } + + @TestMetadata("onBlockStatementSameLine.kt") + public void testOnBlockStatementSameLine() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onBlockStatementSameLine.kt"); + doTest(fileName); + } + + @TestMetadata("onClass.kt") + public void testOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onClass.kt"); + doTest(fileName); + } + + @TestMetadata("onClassObject.kt") + public void testOnClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("onExpression.kt") + public void testOnExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onExpression.kt"); + doTest(fileName); + } + + @TestMetadata("onFunction.kt") + public void testOnFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onFunction.kt"); + doTest(fileName); + } + + @TestMetadata("onLocalVariable.kt") + public void testOnLocalVariable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onLocalVariable.kt"); + doTest(fileName); + } + + @TestMetadata("onObject.kt") + public void testOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onObject.kt"); + doTest(fileName); + } + + @TestMetadata("onParameter.kt") + public void testOnParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onParameter.kt"); + doTest(fileName); + } + + @TestMetadata("onProperty.kt") + public void testOnProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onProperty.kt"); + doTest(fileName); + } + + @TestMetadata("onPropertyAccessor.kt") + public void testOnPropertyAccessor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning/onPropertyAccessor.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SyntheticExtensions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSyntheticExtensions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaProperties extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("AbbreviationName.kt") + public void testAbbreviationName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/AbbreviationName.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInJavaProperties() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Bases.kt") + public void testBases() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt"); + doTest(fileName); + } + + @TestMetadata("CompiledClass.kt") + public void testCompiledClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/CompiledClass.kt"); + doTest(fileName); + } + + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Deprecated.kt"); + doTest(fileName); + } + + @TestMetadata("FalseGetters.kt") + public void testFalseGetters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FalseGetters.kt"); + doTest(fileName); + } + + @TestMetadata("FalseSetters.kt") + public void testFalseSetters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FalseSetters.kt"); + doTest(fileName); + } + + @TestMetadata("FromTwoBases.kt") + public void testFromTwoBases() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FromTwoBases.kt"); + doTest(fileName); + } + + @TestMetadata("GenericClass.kt") + public void testGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("GetA.kt") + public void testGetA() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GetA.kt"); + doTest(fileName); + } + + @TestMetadata("Getter.kt") + public void testGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt"); + doTest(fileName); + } + + @TestMetadata("GetterAndSetter.kt") + public void testGetterAndSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GetterAndSetter.kt"); + doTest(fileName); + } + + @TestMetadata("ImplicitReceiver.kt") + public void testImplicitReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/ImplicitReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("IsNaming.kt") + public void testIsNaming() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/IsNaming.kt"); + doTest(fileName); + } + + @TestMetadata("JavaOverridesKotlin.kt") + public void testJavaOverridesKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/JavaOverridesKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("KotlinOverridesJava.kt") + public void testKotlinOverridesJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.kt"); + doTest(fileName); + } + + @TestMetadata("KotlinOverridesJava2.kt") + public void testKotlinOverridesJava2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava2.kt"); + doTest(fileName); + } + + @TestMetadata("KotlinOverridesJava3.kt") + public void testKotlinOverridesJava3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava3.kt"); + doTest(fileName); + } + + @TestMetadata("KotlinOverridesJava4.kt") + public void testKotlinOverridesJava4() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava4.kt"); + doTest(fileName); + } + + @TestMetadata("KotlinOverridesJava5.kt") + public void testKotlinOverridesJava5() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava5.kt"); + doTest(fileName); + } + + @TestMetadata("OnlyAscii.kt") + public void testOnlyAscii() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyAscii.kt"); + doTest(fileName); + } + + @TestMetadata("OnlyPublic.kt") + public void testOnlyPublic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideGetterOnly.kt") + public void testOverrideGetterOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OverrideGetterOnly.kt"); + doTest(fileName); + } + + @TestMetadata("SetterHasHigherAccess.kt") + public void testSetterHasHigherAccess() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt"); + doTest(fileName); + } + + @TestMetadata("SetterOnly.kt") + public void testSetterOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterOnly.kt"); + doTest(fileName); + } + + @TestMetadata("SmartCast.kt") + public void testSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("SmartCastImplicitReceiver.kt") + public void testSmartCastImplicitReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SmartCastImplicitReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("SyntheticJavaPropertyReference.kt") + public void testSyntheticJavaPropertyReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SyntheticJavaPropertyReference.kt"); + doTest(fileName); + } + + @TestMetadata("TypeAnnotation.kt") + public void testTypeAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/TypeAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParameterReceiver.kt") + public void testTypeParameterReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/TypeParameterReceiver.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SamAdapters extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInSamAdapters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Deprecated.kt"); + doTest(fileName); + } + + @TestMetadata("GenericClass.kt") + public void testGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("GenericMethod.kt") + public void testGenericMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt"); + doTest(fileName); + } + + @TestMetadata("GenericMethodInGenericClass.kt") + public void testGenericMethodInGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassInGeneric.kt") + public void testInnerClassInGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("NoNamedArgsAllowed.kt") + public void testNoNamedArgsAllowed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt"); + doTest(fileName); + } + + @TestMetadata("overloadResolution.kt") + public void testOverloadResolution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolution.kt"); + doTest(fileName); + } + + @TestMetadata("overloadResolutionStatic.kt") + public void testOverloadResolutionStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStatic.kt"); + doTest(fileName); + } + + @TestMetadata("overloadResolutionStaticWithoutRefinedSams.kt") + public void testOverloadResolutionStaticWithoutRefinedSams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStaticWithoutRefinedSams.kt"); + doTest(fileName); + } + + @TestMetadata("overloadResolutionWithoutRefinedSams.kt") + public void testOverloadResolutionWithoutRefinedSams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionWithoutRefinedSams.kt"); + doTest(fileName); + } + + @TestMetadata("PackageLocal.kt") + public void testPackageLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt"); + doTest(fileName); + } + + @TestMetadata("ParameterTypeAnnotation.kt") + public void testParameterTypeAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("PassNull.kt") + public void testPassNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PassNull.kt"); + doTest(fileName); + } + + @TestMetadata("Private.kt") + public void testPrivate() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt"); + doTest(fileName); + } + + @TestMetadata("Protected.kt") + public void testProtected() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Protected.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeAnnotation.kt") + public void testReturnTypeAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ReturnTypeAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ThisAndSuper extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInThisAndSuper() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambigousLabelOnThis.kt") + public void testAmbigousLabelOnThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/ambigousLabelOnThis.kt"); + doTest(fileName); + } + + @TestMetadata("genericQualifiedSuperOverridden.kt") + public void testGenericQualifiedSuperOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/genericQualifiedSuperOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("notAccessibleSuperInTrait.kt") + public void testNotAccessibleSuperInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/notAccessibleSuperInTrait.kt"); + doTest(fileName); + } + + @TestMetadata("qualifiedSuperOverridden.kt") + public void testQualifiedSuperOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/qualifiedSuperOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("QualifiedThis.kt") + public void testQualifiedThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/QualifiedThis.kt"); + doTest(fileName); + } + + @TestMetadata("Super.kt") + public void testSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/Super.kt"); + doTest(fileName); + } + + @TestMetadata("superInExtensionFunction.kt") + public void testSuperInExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunction.kt"); + doTest(fileName); + } + + @TestMetadata("superInExtensionFunctionCall.kt") + public void testSuperInExtensionFunctionCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunctionCall.kt"); + doTest(fileName); + } + + @TestMetadata("superInToplevelFunction.kt") + public void testSuperInToplevelFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/superInToplevelFunction.kt"); + doTest(fileName); + } + + @TestMetadata("superIsNotAnExpression.kt") + public void testSuperIsNotAnExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/superIsNotAnExpression.kt"); + doTest(fileName); + } + + @TestMetadata("thisInFunctionLiterals.kt") + public void testThisInFunctionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("thisInInnerClasses.kt") + public void testThisInInnerClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/thisInInnerClasses.kt"); + doTest(fileName); + } + + @TestMetadata("thisInPropertyInitializer.kt") + public void testThisInPropertyInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/thisInPropertyInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("thisInToplevelFunction.kt") + public void testThisInToplevelFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/thisInToplevelFunction.kt"); + doTest(fileName); + } + + @TestMetadata("traitSuperCall.kt") + public void testTraitSuperCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/traitSuperCall.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class UnqualifiedSuper extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInUnqualifiedSuper() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ambiguousSuperWithGenerics.kt") + public void testAmbiguousSuperWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuper.kt") + public void testUnqualifiedSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuper.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithAbstractMembers.kt") + public void testUnqualifiedSuperWithAbstractMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithAbstractMembers.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithCallableProperty.kt") + public void testUnqualifiedSuperWithCallableProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithDeeperHierarchies.kt") + public void testUnqualifiedSuperWithDeeperHierarchies() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithDeeperHierarchies.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithGenerics.kt") + public void testUnqualifiedSuperWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithInnerClass.kt") + public void testUnqualifiedSuperWithInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithInterfaces.kt") + public void testUnqualifiedSuperWithInterfaces() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInterfaces.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithLocalClass.kt") + public void testUnqualifiedSuperWithLocalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithLocalClass.kt"); + doTest(fileName); + } + + @TestMetadata("unqualifiedSuperWithUnresolvedBase.kt") + public void testUnqualifiedSuperWithUnresolvedBase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithUnresolvedBase.kt"); + doTest(fileName); + } + + @TestMetadata("withMethodOfAnyOverridenInInterface.kt") + public void testWithMethodOfAnyOverridenInInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOfAnyOverridenInInterface.kt"); + doTest(fileName); + } + + @TestMetadata("withMethodOverriddenInAnotherSupertype.kt") + public void testWithMethodOverriddenInAnotherSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOverriddenInAnotherSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("withMethodsOfAny.kt") + public void testWithMethodsOfAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodsOfAny.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/traitWithRequired") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TraitWithRequired extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTraitWithRequired() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("traitRequiresAny.kt") + public void testTraitRequiresAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/traitWithRequired/traitRequiresAny.kt"); + doTest(fileName); + } + + @TestMetadata("traitSupertypeList.kt") + public void testTraitSupertypeList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameters extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("cannotHaveManyClassUpperBounds.kt") + public void testCannotHaveManyClassUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/cannotHaveManyClassUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("deprecatedSyntax.kt") + public void testDeprecatedSyntax() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/deprecatedSyntax.kt"); + doTest(fileName); + } + + @TestMetadata("extFunctionTypeAsUpperBound.kt") + public void testExtFunctionTypeAsUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/extFunctionTypeAsUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("functionTypeAsUpperBound.kt") + public void testFunctionTypeAsUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/functionTypeAsUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("misplacedConstraints.kt") + public void testMisplacedConstraints() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt"); + doTest(fileName); + } + + @TestMetadata("propertyTypeParameters.kt") + public void testPropertyTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/propertyTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("propertyTypeParametersWithUpperBounds.kt") + public void testPropertyTypeParametersWithUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/propertyTypeParametersWithUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("repeatedBound.kt") + public void testRepeatedBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/repeatedBound.kt"); + doTest(fileName); + } + + @TestMetadata("upperBoundCannotBeArray.kt") + public void testUpperBoundCannotBeArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typeParameters/upperBoundCannotBeArray.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/typealias") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Typealias extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("aliasesOnly.kt") + public void testAliasesOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/aliasesOnly.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInTypealias() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotationsOnTypeAliases.kt") + public void testAnnotationsOnTypeAliases() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/annotationsOnTypeAliases.kt"); + doTest(fileName); + } + + @TestMetadata("boundViolationInTypeAliasConstructor.kt") + public void testBoundViolationInTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("boundsViolationInDeepTypeAliasExpansion.kt") + public void testBoundsViolationInDeepTypeAliasExpansion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/boundsViolationInDeepTypeAliasExpansion.kt"); + doTest(fileName); + } + + @TestMetadata("boundsViolationInTypeAliasExpansion.kt") + public void testBoundsViolationInTypeAliasExpansion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt"); + doTest(fileName); + } + + @TestMetadata("boundsViolationInTypeAliasRHS.kt") + public void testBoundsViolationInTypeAliasRHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasRHS.kt"); + doTest(fileName); + } + + @TestMetadata("capturingTypeParametersFromOuterClass.kt") + public void testCapturingTypeParametersFromOuterClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/capturingTypeParametersFromOuterClass.kt"); + doTest(fileName); + } + + @TestMetadata("classReference.kt") + public void testClassReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/classReference.kt"); + doTest(fileName); + } + + @TestMetadata("conflictingProjections.kt") + public void testConflictingProjections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/conflictingProjections.kt"); + doTest(fileName); + } + + @TestMetadata("constructorCallThroughPrivateAlias.kt") + public void testConstructorCallThroughPrivateAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/constructorCallThroughPrivateAlias.kt"); + doTest(fileName); + } + + @TestMetadata("cyclicInheritanceViaTypeAlias.kt") + public void testCyclicInheritanceViaTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/cyclicInheritanceViaTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("enumEntryQualifier.kt") + public void testEnumEntryQualifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/enumEntryQualifier.kt"); + doTest(fileName); + } + + @TestMetadata("exposedExpandedType.kt") + public void testExposedExpandedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/exposedExpandedType.kt"); + doTest(fileName); + } + + @TestMetadata("functionTypeInTypeAlias.kt") + public void testFunctionTypeInTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/functionTypeInTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("genericTypeAliasConstructor.kt") + public void testGenericTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/genericTypeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("genericTypeAliasObject.kt") + public void testGenericTypeAliasObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/genericTypeAliasObject.kt"); + doTest(fileName); + } + + @TestMetadata("illegalTypeInTypeAliasExpansion.kt") + public void testIllegalTypeInTypeAliasExpansion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/illegalTypeInTypeAliasExpansion.kt"); + doTest(fileName); + } + + @TestMetadata("import.kt") + public void testImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/import.kt"); + doTest(fileName); + } + + @TestMetadata("importFromTypeAliasObject.kt") + public void testImportFromTypeAliasObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt"); + doTest(fileName); + } + + @TestMetadata("inGenerics.kt") + public void testInGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/inGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("inSupertypesList.kt") + public void testInSupertypesList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/inSupertypesList.kt"); + doTest(fileName); + } + + @TestMetadata("inheritedNestedTypeAlias.kt") + public void testInheritedNestedTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/inheritedNestedTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("inhreritedTypeAliasQualifiedByDerivedClass.kt") + public void testInhreritedTypeAliasQualifiedByDerivedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/inhreritedTypeAliasQualifiedByDerivedClass.kt"); + doTest(fileName); + } + + @TestMetadata("innerClassTypeAliasConstructor.kt") + public void testInnerClassTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("innerClassTypeAliasConstructorInSupertypes.kt") + public void testInnerClassTypeAliasConstructorInSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("innerTypeAliasAsType.kt") + public void testInnerTypeAliasAsType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType.kt"); + doTest(fileName); + } + + @TestMetadata("innerTypeAliasAsType2.kt") + public void testInnerTypeAliasAsType2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType2.kt"); + doTest(fileName); + } + + @TestMetadata("innerTypeAliasConstructor.kt") + public void testInnerTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("isAsWithTypeAlias.kt") + public void testIsAsWithTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/isAsWithTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("javaStaticMembersViaTypeAlias.kt") + public void testJavaStaticMembersViaTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/javaStaticMembersViaTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("kt14498.kt") + public void testKt14498() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/kt14498.kt"); + doTest(fileName); + } + + @TestMetadata("kt14498a.kt") + public void testKt14498a() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/kt14498a.kt"); + doTest(fileName); + } + + @TestMetadata("kt14518.kt") + public void testKt14518() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/kt14518.kt"); + doTest(fileName); + } + + @TestMetadata("kt14641.kt") + public void testKt14641() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/kt14641.kt"); + doTest(fileName); + } + + @TestMetadata("kt15734.kt") + public void testKt15734() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/kt15734.kt"); + doTest(fileName); + } + + @TestMetadata("localTypeAlias.kt") + public void testLocalTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/localTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("localTypeAliasConstructor.kt") + public void testLocalTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/localTypeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("localTypeAliasModifiers.kt") + public void testLocalTypeAliasModifiers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/localTypeAliasModifiers.kt"); + doTest(fileName); + } + + @TestMetadata("localTypeAliasRecursive.kt") + public void testLocalTypeAliasRecursive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/localTypeAliasRecursive.kt"); + doTest(fileName); + } + + @TestMetadata("methodReference.kt") + public void testMethodReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/methodReference.kt"); + doTest(fileName); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/nested.kt"); + doTest(fileName); + } + + @TestMetadata("nestedCapturingTypeParameters.kt") + public void testNestedCapturingTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/nestedCapturingTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("nestedSubstituted.kt") + public void testNestedSubstituted() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/nestedSubstituted.kt"); + doTest(fileName); + } + + @TestMetadata("noApproximationInTypeAliasArgumentSubstitution.kt") + public void testNoApproximationInTypeAliasArgumentSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt"); + doTest(fileName); + } + + @TestMetadata("noRHS.kt") + public void testNoRHS() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/noRHS.kt"); + doTest(fileName); + } + + @TestMetadata("parameterRestrictions.kt") + public void testParameterRestrictions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/parameterRestrictions.kt"); + doTest(fileName); + } + + @TestMetadata("parameterSubstitution.kt") + public void testParameterSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/parameterSubstitution.kt"); + doTest(fileName); + } + + @TestMetadata("privateInFile.kt") + public void testPrivateInFile() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/privateInFile.kt"); + doTest(fileName); + } + + @TestMetadata("projectionsInTypeAliasConstructor.kt") + public void testProjectionsInTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/projectionsInTypeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/recursive.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeNothingShouldBeSpecifiedExplicitly.kt") + public void testReturnTypeNothingShouldBeSpecifiedExplicitly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/returnTypeNothingShouldBeSpecifiedExplicitly.kt"); + doTest(fileName); + } + + @TestMetadata("simpleTypeAlias.kt") + public void testSimpleTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/simpleTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("starProjection.kt") + public void testStarProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/starProjection.kt"); + doTest(fileName); + } + + @TestMetadata("starProjectionInTypeAliasArgument.kt") + public void testStarProjectionInTypeAliasArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/starProjectionInTypeAliasArgument.kt"); + doTest(fileName); + } + + @TestMetadata("substitutionVariance.kt") + public void testSubstitutionVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/substitutionVariance.kt"); + doTest(fileName); + } + + @TestMetadata("throwJLException.kt") + public void testThrowJLException() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/throwJLException.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelTypeAliasesOnly.kt") + public void testTopLevelTypeAliasesOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/topLevelTypeAliasesOnly.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasArgumentsInCompanionObject.kt") + public void testTypeAliasArgumentsInCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasArgumentsInCompanionObject.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasArgumentsInConstructor.kt") + public void testTypeAliasArgumentsInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasArgumentsInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasAsBareType.kt") + public void testTypeAliasAsBareType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasAsQualifier.kt") + public void testTypeAliasAsQualifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasAsQualifier.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasAsSuperQualifier.kt") + public void testTypeAliasAsSuperQualifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasAsSuperQualifier.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructor.kt") + public void testTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorCrazyProjections.kt") + public void testTypeAliasConstructorCrazyProjections() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorForInterface.kt") + public void testTypeAliasConstructorForInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForInterface.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorForProjection.kt") + public void testTypeAliasConstructorForProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorForProjectionInSupertypes.kt") + public void testTypeAliasConstructorForProjectionInSupertypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorInSuperCall.kt") + public void testTypeAliasConstructorInSuperCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorInferenceInSupertypesList.kt") + public void testTypeAliasConstructorInferenceInSupertypesList() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorReturnType.kt") + public void testTypeAliasConstructorReturnType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorReturnType.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorTypeArgumentsInference.kt") + public void testTypeAliasConstructorTypeArgumentsInference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt") + public void testTypeAliasConstructorTypeArgumentsInferenceWithNestedCalls() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt") + public void testTypeAliasConstructorTypeArgumentsInferenceWithNestedCalls2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt") + public void testTypeAliasConstructorTypeArgumentsInferenceWithPhantomTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorVsFunction.kt") + public void testTypeAliasConstructorVsFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorVsFunction.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorWrongClass.kt") + public void testTypeAliasConstructorWrongClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongClass.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasConstructorWrongVisibility.kt") + public void testTypeAliasConstructorWrongVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasExpansionRepeatedAnnotations.kt") + public void testTypeAliasExpansionRepeatedAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasExpansionRepeatedAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasForProjectionInSuperInterfaces.kt") + public void testTypeAliasForProjectionInSuperInterfaces() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasForProjectionInSuperInterfaces.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasInAnonymousObjectType.kt") + public void testTypeAliasInAnonymousObjectType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasInAnonymousObjectType.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasInvisibleObject.kt") + public void testTypeAliasInvisibleObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasInvisibleObject.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasNotNull.kt") + public void testTypeAliasNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasObject.kt") + public void testTypeAliasObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasObject.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasObjectWithInvoke.kt") + public void testTypeAliasObjectWithInvoke() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.kt"); + doTest(fileName); + } + + @TestMetadata("typeAliasShouldExpandToClass.kt") + public void testTypeAliasShouldExpandToClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasRhsAnnotations.kt") + public void testTypealiasRhsAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typealiasRhsAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasRhsAnnotationsInArguments.kt") + public void testTypealiasRhsAnnotationsInArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typealiasRhsAnnotationsInArguments.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasRhsRepeatedAnnotationInArguments.kt") + public void testTypealiasRhsRepeatedAnnotationInArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typealiasRhsRepeatedAnnotationInArguments.kt"); + doTest(fileName); + } + + @TestMetadata("typealiasRhsRepeatedAnnotations.kt") + public void testTypealiasRhsRepeatedAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/typealiasRhsRepeatedAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("unsupportedTypeAlias.kt") + public void testUnsupportedTypeAlias() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/unsupportedTypeAlias.kt"); + doTest(fileName); + } + + @TestMetadata("unusedTypeAliasParameter.kt") + public void testUnusedTypeAliasParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/unusedTypeAliasParameter.kt"); + doTest(fileName); + } + + @TestMetadata("wrongNumberOfArgumentsInTypeAliasConstructor.kt") + public void testWrongNumberOfArgumentsInTypeAliasConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/underscoresInNumericLiterals") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class UnderscoresInNumericLiterals extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInUnderscoresInNumericLiterals() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("illegalUnderscores.kt") + public void testIllegalUnderscores() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/underscoresInNumericLiterals/illegalUnderscores.kt"); + doTest(fileName); + } + + @TestMetadata("noUnderscores.kt") + public void testNoUnderscores() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/underscoresInNumericLiterals/noUnderscores.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/unit") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Unit extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInUnit() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("nullableUnit.kt") + public void testNullableUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/unit/nullableUnit.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/varargs") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Varargs extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInVarargs() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AmbiguousVararg.kt") + public void testAmbiguousVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt"); + doTest(fileName); + } + + @TestMetadata("kt1781.kt") + public void testKt1781() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/kt1781.kt"); + doTest(fileName); + } + + @TestMetadata("kt1835.kt") + public void testKt1835() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/kt1835.kt"); + doTest(fileName); + } + + @TestMetadata("kt1838-param.kt") + public void testKt1838_param() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/kt1838-param.kt"); + doTest(fileName); + } + + @TestMetadata("kt1838-val.kt") + public void testKt1838_val() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/kt1838-val.kt"); + doTest(fileName); + } + + @TestMetadata("kt2163.kt") + public void testKt2163() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/kt2163.kt"); + doTest(fileName); + } + + @TestMetadata("kt422.kt") + public void testKt422() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/kt422.kt"); + doTest(fileName); + } + + @TestMetadata("MoreSpecificVarargsOfEqualLength.kt") + public void testMoreSpecificVarargsOfEqualLength() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/MoreSpecificVarargsOfEqualLength.kt"); + doTest(fileName); + } + + @TestMetadata("MostSepcificVarargsWithJava.kt") + public void testMostSepcificVarargsWithJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/MostSepcificVarargsWithJava.kt"); + doTest(fileName); + } + + @TestMetadata("NilaryVsVararg.kt") + public void testNilaryVsVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/NilaryVsVararg.kt"); + doTest(fileName); + } + + @TestMetadata("NullableTypeForVarargArgument.kt") + public void testNullableTypeForVarargArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt"); + doTest(fileName); + } + + @TestMetadata("UnaryVsVararg.kt") + public void testUnaryVsVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/UnaryVsVararg.kt"); + doTest(fileName); + } + + @TestMetadata("varargInSetter.kt") + public void testVarargInSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargInSetter.kt"); + doTest(fileName); + } + + @TestMetadata("varargIterator.kt") + public void testVarargIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargIterator.kt"); + doTest(fileName); + } + + @TestMetadata("varargOfNothing.kt") + public void testVarargOfNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargOfNothing.kt"); + doTest(fileName); + } + + @TestMetadata("varargsAndFunctionLiterals.kt") + public void testVarargsAndFunctionLiterals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargsAndFunctionLiterals.kt"); + doTest(fileName); + } + + @TestMetadata("varargsAndOut1.kt") + public void testVarargsAndOut1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargsAndOut1.kt"); + doTest(fileName); + } + + @TestMetadata("varargsAndOut2.kt") + public void testVarargsAndOut2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargsAndOut2.kt"); + doTest(fileName); + } + + @TestMetadata("varargsAndPair.kt") + public void testVarargsAndPair() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/varargs/varargsAndPair.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/variance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Variance extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInVariance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Class.kt") + public void testClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/Class.kt"); + doTest(fileName); + } + + @TestMetadata("ea1337846.kt") + public void testEa1337846() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/ea1337846.kt"); + doTest(fileName); + } + + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/Function.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionTypes.kt") + public void testFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/FunctionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("InPosition.kt") + public void testInPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/InPosition.kt"); + doTest(fileName); + } + + @TestMetadata("InvariantPosition.kt") + public void testInvariantPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/InvariantPosition.kt"); + doTest(fileName); + } + + @TestMetadata("NullableTypes.kt") + public void testNullableTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/NullableTypes.kt"); + doTest(fileName); + } + + @TestMetadata("OutPosition.kt") + public void testOutPosition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/OutPosition.kt"); + doTest(fileName); + } + + @TestMetadata("PrimaryConstructor.kt") + public void testPrimaryConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("ValProperty.kt") + public void testValProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/ValProperty.kt"); + doTest(fileName); + } + + @TestMetadata("VarProperty.kt") + public void testVarProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/VarProperty.kt"); + doTest(fileName); + } + + @TestMetadata("Visibility.kt") + public void testVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/Visibility.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/diagnostics/tests/variance/privateToThis") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PrivateToThis extends AbstractDiagnosticsUsingJavacTest { + @TestMetadata("Abstract.kt") + public void testAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/privateToThis/Abstract.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInPrivateToThis() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("FunctionCall.kt") + public void testFunctionCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt"); + doTest(fileName); + } + + @TestMetadata("GetVal.kt") + public void testGetVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt"); + doTest(fileName); + } + + @TestMetadata("SetVar.kt") + public void testSetVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt"); + doTest(fileName); + } + + @TestMetadata("ValReassigned.kt") + public void testValReassigned() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/diagnostics/tests/when") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class When extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInWhen() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AnnotatedWhenStatement.kt") + public void testAnnotatedWhenStatement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.kt"); + doTest(fileName); + } + + @TestMetadata("BranchBypassVal.kt") + public void testBranchBypassVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/BranchBypassVal.kt"); + doTest(fileName); + } + + @TestMetadata("BranchBypassVar.kt") + public void testBranchBypassVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/BranchBypassVar.kt"); + doTest(fileName); + } + + @TestMetadata("BranchFalseBypass.kt") + public void testBranchFalseBypass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/BranchFalseBypass.kt"); + doTest(fileName); + } + + @TestMetadata("BranchFalseBypassElse.kt") + public void testBranchFalseBypassElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.kt"); + doTest(fileName); + } + + @TestMetadata("CommaInWhenConditionWithoutArgument.kt") + public void testCommaInWhenConditionWithoutArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt"); + doTest(fileName); + } + + @TestMetadata("DuplicatedLabels.kt") + public void testDuplicatedLabels() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/DuplicatedLabels.kt"); + doTest(fileName); + } + + @TestMetadata("ElseOnNullableEnum.kt") + public void testElseOnNullableEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.kt"); + doTest(fileName); + } + + @TestMetadata("ElseOnNullableEnumWithSmartCast.kt") + public void testElseOnNullableEnumWithSmartCast() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.kt"); + doTest(fileName); + } + + @TestMetadata("EmptyConditionWithExpression.kt") + public void testEmptyConditionWithExpression() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/EmptyConditionWithExpression.kt"); + doTest(fileName); + } + + @TestMetadata("EmptyConditionWithExpressionEnum.kt") + public void testEmptyConditionWithExpressionEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/EmptyConditionWithExpressionEnum.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveBoolean.kt") + public void testExhaustiveBoolean() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveBoolean.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveBooleanBrackets.kt") + public void testExhaustiveBooleanBrackets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanBrackets.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveBooleanComplex.kt") + public void testExhaustiveBooleanComplex() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanComplex.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveBooleanNullable.kt") + public void testExhaustiveBooleanNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanNullable.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveBreakContinue.kt") + public void testExhaustiveBreakContinue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveEnumIs.kt") + public void testExhaustiveEnumIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveEnumMixed.kt") + public void testExhaustiveEnumMixed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveInitialization.kt") + public void testExhaustiveInitialization() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveNoInitialization.kt") + public void testExhaustiveNoInitialization() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveNullable.kt") + public void testExhaustiveNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustivePlatformEnum.kt") + public void testExhaustivePlatformEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustivePlatformEnumAnnotated.kt") + public void testExhaustivePlatformEnumAnnotated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustivePlatformEnumElse.kt") + public void testExhaustivePlatformEnumElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumElse.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustivePlatformEnumNull.kt") + public void testExhaustivePlatformEnumNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumNull.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustivePlatformEnumStatement.kt") + public void testExhaustivePlatformEnumStatement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveReturn.kt") + public void testExhaustiveReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveReturnThrow.kt") + public void testExhaustiveReturnThrow() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveValOverConditionalInit.kt") + public void testExhaustiveValOverConditionalInit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveVarOverConditionalInit.kt") + public void testExhaustiveVarOverConditionalInit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWithNullabilityCheck.kt") + public void testExhaustiveWithNullabilityCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWithNullabilityCheckBefore.kt") + public void testExhaustiveWithNullabilityCheckBefore() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWithNullabilityCheckBoolean.kt") + public void testExhaustiveWithNullabilityCheckBoolean() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt"); + doTest(fileName); + } + + @TestMetadata("ExhaustiveWithNullabilityCheckElse.kt") + public void testExhaustiveWithNullabilityCheckElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt"); + doTest(fileName); + } + + @TestMetadata("kt10439.kt") + public void testKt10439() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/kt10439.kt"); + doTest(fileName); + } + + @TestMetadata("kt10809.kt") + public void testKt10809() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/kt10809.kt"); + doTest(fileName); + } + + @TestMetadata("kt10811.kt") + public void testKt10811() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/kt10811.kt"); + doTest(fileName); + } + + @TestMetadata("kt4434.kt") + public void testKt4434() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/kt4434.kt"); + doTest(fileName); + } + + @TestMetadata("kt9929.kt") + public void testKt9929() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/kt9929.kt"); + doTest(fileName); + } + + @TestMetadata("kt9972.kt") + public void testKt9972() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/kt9972.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseExpectedUnit.kt") + public void testNoElseExpectedUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseNoExpectedType.kt") + public void testNoElseNoExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseReturnedCoercionToUnit.kt") + public void testNoElseReturnedCoercionToUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseReturnedFromLambdaExpectedInt.kt") + public void testNoElseReturnedFromLambdaExpectedInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseReturnedNonUnit.kt") + public void testNoElseReturnedNonUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseReturnedUnit.kt") + public void testNoElseReturnedUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt"); + doTest(fileName); + } + + @TestMetadata("NoElseWhenStatement.kt") + public void testNoElseWhenStatement() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NoElseWhenStatement.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveBooleanNullable.kt") + public void testNonExhaustiveBooleanNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustivePlatformEnum.kt") + public void testNonExhaustivePlatformEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWarning.kt") + public void testNonExhaustiveWarning() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWarningElse.kt") + public void testNonExhaustiveWarningElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningElse.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWarningFalse.kt") + public void testNonExhaustiveWarningFalse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWarningForSealedClass.kt") + public void testNonExhaustiveWarningForSealedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWarningNull.kt") + public void testNonExhaustiveWarningNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningNull.kt"); + doTest(fileName); + } + + @TestMetadata("NonExhaustiveWithNullabilityCheck.kt") + public void testNonExhaustiveWithNullabilityCheck() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyNotInitialized.kt") + public void testPropertyNotInitialized() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt"); + doTest(fileName); + } + + @TestMetadata("RedundantElse.kt") + public void testRedundantElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/RedundantElse.kt"); + doTest(fileName); + } + + @TestMetadata("ReservedExhaustiveWhen.kt") + public void testReservedExhaustiveWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelSealed.kt") + public void testTopLevelSealed() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/TopLevelSealed.kt"); + doTest(fileName); + } + + @TestMetadata("When.kt") + public void testWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/When.kt"); + doTest(fileName); + } + + @TestMetadata("whenAndLambdaWithExpectedType.kt") + public void testWhenAndLambdaWithExpectedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt"); + doTest(fileName); + } + + @TestMetadata("WhenTypeDisjunctions.kt") + public void testWhenTypeDisjunctions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt"); + doTest(fileName); + } + + @TestMetadata("whenWithNothingAndLambdas.kt") + public void testWhenWithNothingAndLambdas() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Diagnostics extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInDiagnostics() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Functions extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInFunctions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inference extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt6176.kt") + public void testKt6176() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Invoke extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInInvoke() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class OnObjects extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInOnObjects() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("invokeOnClassObject1.kt") + public void testInvokeOnClassObject1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObject1.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnClassObject2.kt") + public void testInvokeOnClassObject2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObject2.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnClassObjectOfNestedClass1.kt") + public void testInvokeOnClassObjectOfNestedClass1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObjectOfNestedClass1.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnClassObjectOfNestedClass2.kt") + public void testInvokeOnClassObjectOfNestedClass2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObjectOfNestedClass2.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnEnum1.kt") + public void testInvokeOnEnum1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnEnum1.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnEnum2.kt") + public void testInvokeOnEnum2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnEnum2.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnImportedEnum1.kt") + public void testInvokeOnImportedEnum1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnImportedEnum1.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnImportedEnum2.kt") + public void testInvokeOnImportedEnum2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnImportedEnum2.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnObject1.kt") + public void testInvokeOnObject1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnObject1.kt"); + doTest(fileName); + } + + @TestMetadata("invokeOnObject2.kt") + public void testInvokeOnObject2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnObject2.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TailRecursion extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInTailRecursion() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("defaultArgs.kt") + public void testDefaultArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.kt"); + doTest(fileName); + } + + @TestMetadata("defaultArgsOverridden.kt") + public void testDefaultArgsOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("extensionTailCall.kt") + public void testExtensionTailCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.kt"); + doTest(fileName); + } + + @TestMetadata("functionWithNoTails.kt") + public void testFunctionWithNoTails() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.kt"); + doTest(fileName); + } + + @TestMetadata("functionWithNonTailRecursions.kt") + public void testFunctionWithNonTailRecursions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.kt"); + doTest(fileName); + } + + @TestMetadata("functionWithoutAnnotation.kt") + public void testFunctionWithoutAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithoutAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("infixCall.kt") + public void testInfixCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.kt"); + doTest(fileName); + } + + @TestMetadata("infixRecursiveCall.kt") + public void testInfixRecursiveCall() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.kt"); + doTest(fileName); + } + + @TestMetadata("insideElvis.kt") + public void testInsideElvis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.kt"); + doTest(fileName); + } + + @TestMetadata("labeledThisReferences.kt") + public void testLabeledThisReferences() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.kt"); + doTest(fileName); + } + + @TestMetadata("loops.kt") + public void testLoops() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.kt"); + doTest(fileName); + } + + @TestMetadata("multilevelBlocks.kt") + public void testMultilevelBlocks() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.kt"); + doTest(fileName); + } + + @TestMetadata("realIteratorFoldl.kt") + public void testRealIteratorFoldl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.kt"); + doTest(fileName); + } + + @TestMetadata("realStringEscape.kt") + public void testRealStringEscape() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.kt"); + doTest(fileName); + } + + @TestMetadata("realStringRepeat.kt") + public void testRealStringRepeat() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveCallInLambda.kt") + public void testRecursiveCallInLambda() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveCallInLocalFunction.kt") + public void testRecursiveCallInLocalFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.kt"); + doTest(fileName); + } + + @TestMetadata("recursiveInnerFunction.kt") + public void testRecursiveInnerFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt"); + doTest(fileName); + } + + @TestMetadata("returnIf.kt") + public void testReturnIf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.kt"); + doTest(fileName); + } + + @TestMetadata("returnInCatch.kt") + public void testReturnInCatch() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.kt"); + doTest(fileName); + } + + @TestMetadata("returnInFinally.kt") + public void testReturnInFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.kt"); + doTest(fileName); + } + + @TestMetadata("returnInIfInFinally.kt") + public void testReturnInIfInFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.kt"); + doTest(fileName); + } + + @TestMetadata("returnInParentheses.kt") + public void testReturnInParentheses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.kt"); + doTest(fileName); + } + + @TestMetadata("returnInTry.kt") + public void testReturnInTry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.kt"); + doTest(fileName); + } + + @TestMetadata("simpleBlock.kt") + public void testSimpleBlock() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.kt"); + doTest(fileName); + } + + @TestMetadata("simpleReturn.kt") + public void testSimpleReturn() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.kt"); + doTest(fileName); + } + + @TestMetadata("simpleReturnWithElse.kt") + public void testSimpleReturnWithElse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.kt"); + doTest(fileName); + } + + @TestMetadata("sum.kt") + public void testSum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.kt"); + doTest(fileName); + } + + @TestMetadata("tailCallInBlockInParentheses.kt") + public void testTailCallInBlockInParentheses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.kt"); + doTest(fileName); + } + + @TestMetadata("tailCallInParentheses.kt") + public void testTailCallInParentheses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.kt"); + doTest(fileName); + } + + @TestMetadata("tailRecursionInFinally.kt") + public void testTailRecursionInFinally() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.kt"); + doTest(fileName); + } + + @TestMetadata("thisReferences.kt") + public void testThisReferences() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.kt"); + doTest(fileName); + } + + @TestMetadata("unitBlocks.kt") + public void testUnitBlocks() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.kt"); + doTest(fileName); + } + + @TestMetadata("whenWithCondition.kt") + public void testWhenWithCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.kt"); + doTest(fileName); + } + + @TestMetadata("whenWithInRange.kt") + public void testWhenWithInRange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.kt"); + doTest(fileName); + } + + @TestMetadata("whenWithIs.kt") + public void testWhenWithIs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.kt"); + doTest(fileName); + } + + @TestMetadata("whenWithoutCondition.kt") + public void testWhenWithoutCondition() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/codegen/box/diagnostics/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractDiagnosticsUsingJavacTest { + public void testAllFilesPresentInVararg() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("kt4172.kt") + public void testKt4172() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/diagnostics/vararg/kt4172.kt"); + doTest(fileName); + } + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java new file mode 100644 index 00000000000..a31837bfabc --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java @@ -0,0 +1,824 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac; + +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") +@RunWith(JUnit3RunnerWithInners.class) +public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest { + @TestMetadata("compiler/testData/javac/diagnostics/tests") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Tests extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInTests() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/Annotations.kt"); + doTest(fileName); + } + + @TestMetadata("ConstantValues.kt") + public void testConstantValues() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/ConstantValues.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/imports") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Imports extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInImports() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); + doTest(fileName); + } + + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") + public void testCurrentPackageAndExplicitNestedImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") + public void testCurrentPackageAndNestedAsteriskImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt"); + doTest(fileName); + } + + @TestMetadata("ImportGenericVsPackage.kt") + public void testImportGenericVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt"); + doTest(fileName); + } + + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt"); + doTest(fileName); + } + + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt"); + doTest(fileName); + } + + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt"); + doTest(fileName); + } + + @TestMetadata("NestedAndTopLevelClassClash.kt") + public void testNestedAndTopLevelClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt"); + doTest(fileName); + } + + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt"); + doTest(fileName); + } + + @TestMetadata("PackageExplicitAndStartImport.kt") + public void testPackageExplicitAndStartImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt"); + doTest(fileName); + } + + @TestMetadata("PackagePrivateAndPublicNested.kt") + public void testPackagePrivateAndPublicNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelClassVsPackage2.kt") + public void testTopLevelClassVsPackage2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/inheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inheritance extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("IheritanceOfInner.kt") + public void testIheritanceOfInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt"); + doTest(fileName); + } + + @TestMetadata("InheritanceAmbiguity.kt") + public void testInheritanceAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("InheritanceAmbiguity2.kt") + public void testInheritanceAmbiguity2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt"); + doTest(fileName); + } + + @TestMetadata("InheritanceAmbiguity3.kt") + public void testInheritanceAmbiguity3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt"); + doTest(fileName); + } + + @TestMetadata("InheritanceAmbiguity4.kt") + public void testInheritanceAmbiguity4() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt"); + doTest(fileName); + } + + @TestMetadata("InheritanceWithKotlin.kt") + public void testInheritanceWithKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("InheritanceWithKotlinClasses.kt") + public void testInheritanceWithKotlinClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedInner.kt") + public void testInheritedInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedInner2.kt") + public void testInheritedInner2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") + public void testInheritedInnerAndSupertypeWithSameName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedInnerUsageInInner.kt") + public void testInheritedInnerUsageInInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedKotlinInner.kt") + public void testInheritedKotlinInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt"); + doTest(fileName); + } + + @TestMetadata("InnerAndInheritedInner.kt") + public void testInnerAndInheritedInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt"); + doTest(fileName); + } + + @TestMetadata("ManyInheritedClasses.kt") + public void testManyInheritedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("NoAmbiguity.kt") + public void testNoAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt"); + doTest(fileName); + } + + @TestMetadata("NoAmbiguity2.kt") + public void testNoAmbiguity2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt"); + doTest(fileName); + } + + @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") + public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); + doTest(fileName); + } + + @TestMetadata("SuperTypeWithSameInner.kt") + public void testSuperTypeWithSameInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt"); + doTest(fileName); + } + + @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") + public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/inners") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inners extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInInners() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inners"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt"); + doTest(fileName); + } + + @TestMetadata("ComplexCase2.kt") + public void testComplexCase2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt"); + doTest(fileName); + } + + @TestMetadata("CurrentPackageAndInner.kt") + public void testCurrentPackageAndInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt"); + doTest(fileName); + } + + @TestMetadata("ImportThriceNestedClass.kt") + public void testImportThriceNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("InnerInInner.kt") + public void testInnerInInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt"); + doTest(fileName); + } + + @TestMetadata("Nested.kt") + public void testNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/Nested.kt"); + doTest(fileName); + } + + @TestMetadata("ThriceNestedClass.kt") + public void testThriceNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class QualifiedExpression extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); + doTest(fileName); + } + + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); + doTest(fileName); + } + + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/typeParameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameters extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Clash.kt") + public void testClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt"); + doTest(fileName); + } + + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt"); + doTest(fileName); + } + + @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") + public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); + doTest(fileName); + } + + @TestMetadata("InnerWithTypeParameter.kt") + public void testInnerWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("NestedWithInner.kt") + public void testNestedWithInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt"); + doTest(fileName); + } + + @TestMetadata("SeveralInnersWithTypeParameters.kt") + public void testSeveralInnersWithTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") + public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TestsWithoutJavac extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInTestsWithoutJavac() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/Annotations.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ConstantValues.kt") + public void testConstantValues() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/ConstantValues.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/imports") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Imports extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInImports() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") + public void testCurrentPackageAndExplicitNestedImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") + public void testCurrentPackageAndNestedAsteriskImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ImportGenericVsPackage.kt") + public void testImportGenericVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("NestedAndTopLevelClassClash.kt") + public void testNestedAndTopLevelClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("PackageExplicitAndStartImport.kt") + public void testPackageExplicitAndStartImport() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("PackagePrivateAndPublicNested.kt") + public void testPackagePrivateAndPublicNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("TopLevelClassVsPackage2.kt") + public void testTopLevelClassVsPackage2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt"); + doTestWithoutJavacWrapper(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/inheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inheritance extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inheritance"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("IheritanceOfInner.kt") + public void testIheritanceOfInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritanceAmbiguity.kt") + public void testInheritanceAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritanceAmbiguity2.kt") + public void testInheritanceAmbiguity2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritanceAmbiguity3.kt") + public void testInheritanceAmbiguity3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritanceAmbiguity4.kt") + public void testInheritanceAmbiguity4() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritanceWithKotlin.kt") + public void testInheritanceWithKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritanceWithKotlinClasses.kt") + public void testInheritanceWithKotlinClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritedInner.kt") + public void testInheritedInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritedInner2.kt") + public void testInheritedInner2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") + public void testInheritedInnerAndSupertypeWithSameName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritedInnerUsageInInner.kt") + public void testInheritedInnerUsageInInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritedKotlinInner.kt") + public void testInheritedKotlinInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InnerAndInheritedInner.kt") + public void testInnerAndInheritedInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ManyInheritedClasses.kt") + public void testManyInheritedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("NoAmbiguity.kt") + public void testNoAmbiguity() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("NoAmbiguity2.kt") + public void testNoAmbiguity2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") + public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("SuperTypeWithSameInner.kt") + public void testSuperTypeWithSameInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") + public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); + doTestWithoutJavacWrapper(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/inners") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inners extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInInners() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inners"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ComplexCase2.kt") + public void testComplexCase2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("CurrentPackageAndInner.kt") + public void testCurrentPackageAndInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ImportThriceNestedClass.kt") + public void testImportThriceNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InnerInInner.kt") + public void testInnerInInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("Nested.kt") + public void testNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/Nested.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ThriceNestedClass.kt") + public void testThriceNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt"); + doTestWithoutJavacWrapper(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class QualifiedExpression extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + doTestWithoutJavacWrapper(fileName); + } + } + + @TestMetadata("compiler/testData/javac/diagnostics/tests/typeParameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameters extends AbstractJavacDiagnosticsTest { + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Clash.kt") + public void testClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") + public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("InnerWithTypeParameter.kt") + public void testInnerWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("NestedWithInner.kt") + public void testNestedWithInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("SeveralInnersWithTypeParameters.kt") + public void testSeveralInnersWithTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt"); + doTestWithoutJavacWrapper(fileName); + } + + @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") + public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); + doTestWithoutJavacWrapper(fileName); + } + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java new file mode 100644 index 00000000000..7c7921492f3 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java @@ -0,0 +1,143 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers.javac; + +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/foreignAnnotations/tests") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAnnotationsTest { + public void testAllFilesPresentInTests() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("android.kt") + public void testAndroid() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/android.kt"); + doTest(fileName); + } + + @TestMetadata("aosp.kt") + public void testAosp() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/aosp.kt"); + doTest(fileName); + } + + @TestMetadata("eclipse.kt") + public void testEclipse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/eclipse.kt"); + doTest(fileName); + } + + @TestMetadata("findBugsSimple.kt") + public void testFindBugsSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/findBugsSimple.kt"); + doTest(fileName); + } + + @TestMetadata("jsr305NullabilityNicknames.kt") + public void testJsr305NullabilityNicknames() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityNicknames.kt"); + doTest(fileName); + } + + @TestMetadata("jsr305Simple.kt") + public void testJsr305Simple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305Simple.kt"); + doTest(fileName); + } + + @TestMetadata("jsr305Strange.kt") + public void testJsr305Strange() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/jsr305Strange.kt"); + doTest(fileName); + } + + @TestMetadata("lombokSimple.kt") + public void testLombokSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/lombokSimple.kt"); + doTest(fileName); + } + + @TestMetadata("rxjava.kt") + public void testRxjava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/rxjava.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeQualifierDefault extends AbstractJavacForeignAnnotationsTest { + public void testAllFilesPresentInTypeQualifierDefault() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("fieldsAreNullable.kt") + public void testFieldsAreNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/fieldsAreNullable.kt"); + doTest(fileName); + } + + @TestMetadata("nullabilityFromOverridden.kt") + public void testNullabilityFromOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/nullabilityFromOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("overridingDefaultQualifier.kt") + public void testOverridingDefaultQualifier() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/overridingDefaultQualifier.kt"); + doTest(fileName); + } + + @TestMetadata("parametersAreNonnullByDefault.kt") + public void testParametersAreNonnullByDefault() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/parametersAreNonnullByDefault.kt"); + doTest(fileName); + } + + @TestMetadata("parametersAreNonnullByDefaultPackage.kt") + public void testParametersAreNonnullByDefaultPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/parametersAreNonnullByDefaultPackage.kt"); + doTest(fileName); + } + + @TestMetadata("springNullable.kt") + public void testSpringNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullable.kt"); + doTest(fileName); + } + + @TestMetadata("springNullablePackage.kt") + public void testSpringNullablePackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotations/tests/typeQualifierDefault/springNullablePackage.kt"); + doTest(fileName); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt index f3d119527fa..6df6a2e3674 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt @@ -96,11 +96,11 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() { ): Boolean { val environment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable) environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true) environment.configuration.put(JVMConfigurationKeys.OUTPUT_DIRECTORY, outDir) environment.configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE) environment.registerJavac(javaFiles = javaFiles, - kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first())), - compileJava = true) + kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first()))) if (!ktFiles.isEmpty()) { LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment) } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt index 9d09883c6dc..e134d76f287 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt @@ -78,10 +78,10 @@ abstract class AbstractCompileKotlinAgainstJavaTest : TestCaseWithTmpdir() { ): Boolean { val environment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable) environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true) environment.configuration.put(JVMConfigurationKeys.OUTPUT_DIRECTORY, outDir) environment.registerJavac(javaFiles = javaFiles, - kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first())), - compileJava = true) + kotlinFiles = listOf(KotlinTestUtils.loadJetFile(environment.project, ktFiles.first()))) if (!ktFiles.isEmpty()) { LoadDescriptorUtil.compileKotlinToDirAndGetModule(ktFiles, outDir, environment) } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java index 9bb6d2c69af..fb5ca6c895a 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java @@ -126,6 +126,12 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin doTest(fileName); } + @TestMetadata("EnumValues.kt") + public void testEnumValues() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/EnumValues.kt"); + doTest(fileName); + } + @TestMetadata("Inheritance.kt") public void testInheritance() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Inheritance.kt"); @@ -162,6 +168,12 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin doTest(fileName); } + @TestMetadata("InnerWithGenericOuter.kt") + public void testInnerWithGenericOuter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/InnerWithGenericOuter.kt"); + doTest(fileName); + } + @TestMetadata("Interface.kt") public void testInterface() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/Interface.kt"); @@ -186,6 +198,12 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin doTest(fileName); } + @TestMetadata("JavaLangClass.kt") + public void testJavaLangClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/JavaLangClass.kt"); + doTest(fileName); + } + @TestMetadata("ListImpl.kt") public void testListImpl() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/ListImpl.kt"); @@ -330,12 +348,6 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin doTest(fileName); } - @TestMetadata("UseKotlinInner.kt") - public void testUseKotlinInner() throws Exception { - String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/UseKotlinInner.kt"); - doTest(fileName); - } - @TestMetadata("UseKtClass.kt") public void testUseKtClass() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/compileKotlinAgainstJava/UseKtClass.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java new file mode 100644 index 00000000000..a33f22c3588 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java @@ -0,0 +1,5213 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jvm.compiler.javac; + +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") +@RunWith(JUnit3RunnerWithInners.class) +public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("compiler/testData/loadJava/compiledJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompiledJava extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ArrayTypeVariance.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassDoesNotOverrideMethod.java") + public void testClassDoesNotOverrideMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassDoesNotOverrideMethod.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithConstVal.java") + public void testClassWithConstVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithConstVal.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithTypeP.java") + public void testClassWithTypeP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithTypeP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithTypePExtendsIterableP.java") + public void testClassWithTypePExtendsIterableP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithTypePExtendsIterableP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithTypePP.java") + public void testClassWithTypePP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithTypePP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithTypePRefNext.java") + public void testClassWithTypePRefNext() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithTypePRefNext.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithTypePRefSelf.java") + public void testClassWithTypePRefSelf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelf.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassWithTypePRefSelfAndClass.java") + public void testClassWithTypePRefSelfAndClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/ClassWithTypePRefSelfAndClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("FieldAsVar.java") + public void testFieldAsVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/FieldAsVar.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("FieldOfArrayType.java") + public void testFieldOfArrayType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/FieldOfArrayType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("FinalFieldAsVal.java") + public void testFinalFieldAsVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/FinalFieldAsVal.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypes.java") + public void testInheritMethodsDifferentReturnTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypes.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypesGeneric.java") + public void testInheritMethodsDifferentReturnTypesGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InheritMethodsDifferentReturnTypesGeneric.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InnerClass.java") + public void testInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InnerClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InnerClassReferencesOuterTP.java") + public void testInnerClassReferencesOuterTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InnerClassReferencesOuterTP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InnerClassTypeMultipleGeneric.java") + public void testInnerClassTypeMultipleGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InnerClassTypeMultipleGeneric.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InnerClassesInGeneric.java") + public void testInnerClassesInGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InnerOfGeneric.java") + public void testInnerOfGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/InnerOfGeneric.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("IntrinsicCompanionObject.java") + public void testIntrinsicCompanionObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/IntrinsicCompanionObject.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodReferencesOuterClassTP.java") + public void testMethodReferencesOuterClassTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethodReferencesOuterClassTP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodTypePOneUpperBound.java") + public void testMethodTypePOneUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethodTypePOneUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodTypePTwoUpperBounds.java") + public void testMethodTypePTwoUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethodTypePTwoUpperBounds.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithTypeP.java") + public void testMethodWithTypeP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethodWithTypeP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithTypePP.java") + public void testMethodWithTypePP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethodWithTypePP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithTypePRefClassP.java") + public void testMethodWithTypePRefClassP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethodWithTypePRefClassP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethosWithPRefTP.java") + public void testMethosWithPRefTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MethosWithPRefTP.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MyException.java") + public void testMyException() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/MyException.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NestedClass.java") + public void testNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/NestedClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("OverrideMethod.java") + public void testOverrideMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/OverrideMethod.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PackageLocalVisibility.java") + public void testPackageLocalVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/PackageLocalVisibility.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PrivateMembers.java") + public void testPrivateMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/PrivateMembers.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PrivateMembersInHierarchy.java") + public void testPrivateMembersInHierarchy() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/PrivateMembersInHierarchy.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawOverrides.java") + public void testRawOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/RawOverrides.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawTypeWithUpperBound.java") + public void testRawTypeWithUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawUpperBound.java") + public void testRawUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/RawUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RecursiveRawUpperBound.java") + public void testRecursiveRawUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RecursiveWildcardUpperBound.java") + public void testRecursiveWildcardUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RemoveRedundantProjectionKind.java") + public void testRemoveRedundantProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/RemoveRedundantProjectionKind.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Simple.java") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/Simple.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubclassFromNested.java") + public void testSubclassFromNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/SubclassFromNested.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TopLevel$Class.java") + public void testTopLevel$Class() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/TopLevel$Class.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoFields.java") + public void testTwoFields() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/TwoFields.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("UnboundWildcard.java") + public void testUnboundWildcard() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/UnboundWildcard.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("WildcardBounds.java") + public void testWildcardBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/WildcardBounds.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/annotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotatedConstructor.java") + public void testAnnotatedConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotatedEnumEntry.java") + public void testAnnotatedEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotatedField.java") + public void testAnnotatedField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotatedMethod.java") + public void testAnnotatedMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotatedValueParameter.java") + public void testAnnotatedValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotationInParam.java") + public void testAnnotationInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotationRetentions.java") + public void testAnnotationRetentions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AnnotationTargets.java") + public void testAnnotationTargets() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ArithmeticExpressionInParam.java") + public void testArithmeticExpressionInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ArrayOfEnumInParam.java") + public void testArrayOfEnumInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ArrayOfStringInParam.java") + public void testArrayOfStringInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassObjectArrayInParam.java") + public void testClassObjectArrayInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassObjectInParam.java") + public void testClassObjectInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassObjectInParamRaw.java") + public void testClassObjectInParamRaw() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ClassObjectInParamVariance.java") + public void testClassObjectInParamVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("CustomAnnotation.java") + public void testCustomAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("CustomAnnotationWithDefaultParameter.java") + public void testCustomAnnotationWithDefaultParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("EmptyArrayInParam.java") + public void testEmptyArrayInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("EnumArgumentWithCustomToString.java") + public void testEnumArgumentWithCustomToString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("EnumConstructorParameter.java") + public void testEnumConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("EnumInParam.java") + public void testEnumInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/EnumInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("JavaDocDeprecated.java") + public void testJavaDocDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/JavaDocDeprecated.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NestedEnumArgument.java") + public void testNestedEnumArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/NestedEnumArgument.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PrimitiveValueInParam.java") + public void testPrimitiveValueInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/PrimitiveValueInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RecursiveAnnotation.java") + public void testRecursiveAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RecursiveAnnotation2.java") + public void testRecursiveAnnotation2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/RecursiveAnnotation2.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SimpleAnnotation.java") + public void testSimpleAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/SimpleAnnotation.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StringConcatenationInParam.java") + public void testStringConcatenationInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/StringConcatenationInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StringConstantInParam.java") + public void testStringConstantInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/StringConstantInParam.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StringInParam.java") + public void testStringInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/annotations/StringInParam.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/constructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Constructor extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericDeep.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorGenericSimple.java") + public void testConstructorGenericSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericSimple.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorGenericUpperBound.java") + public void testConstructorGenericUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/constructor/ConstructorGenericUpperBound.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/enum/EnumMembers.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("EnumWithSpecializedEntry.java") + public void testEnumWithSpecializedEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("JavaEnum.java") + public void testJavaEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/enum/JavaEnum.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/javaBean") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaBean extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/javaBean/DifferentGetterAndSetter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("JavaBeanAbstractGetter.java") + public void testJavaBeanAbstractGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanAbstractGetter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("JavaBeanVal.java") + public void testJavaBeanVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVal.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("JavaBeanVar.java") + public void testJavaBeanVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVar.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("JavaBeanVarOfGenericType.java") + public void testJavaBeanVarOfGenericType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/javaBean/JavaBeanVarOfGenericType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSetters.java") + public void testTwoSetters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/javaBean/TwoSetters.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinSignature extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("AllBoundsInWhen.java") + public void testAllBoundsInWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/AllBoundsInWhen.java"); + doTestCompiledJava(fileName); + } + + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/ArrayType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorWithNewTypeParams.java") + public void testConstructorWithNewTypeParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithNewTypeParams.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorWithParentTypeParams.java") + public void testConstructorWithParentTypeParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithParentTypeParams.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorWithSeveralParams.java") + public void testConstructorWithSeveralParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithSeveralParams.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorWithoutParams.java") + public void testConstructorWithoutParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/ConstructorWithoutParams.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("CustomProjectionKind.java") + public void testCustomProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/CustomProjectionKind.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithFunctionTypes.java") + public void testMethodWithFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithFunctionTypes.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithGenerics.java") + public void testMethodWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithGenerics.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithMappedClasses.java") + public void testMethodWithMappedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithMappedClasses.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithTypeParameters.java") + public void testMethodWithTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithTypeParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodWithVararg.java") + public void testMethodWithVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/MethodWithVararg.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PropertyArrayTypes.java") + public void testPropertyArrayTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyArrayTypes.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PropertyComplexTypes.java") + public void testPropertyComplexTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/PropertyComplexTypes.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PropertySimpleType.java") + public void testPropertySimpleType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/PropertySimpleType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StarProjection.java") + public void testStarProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/StarProjection.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/error") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Error extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongProjectionKind.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("WrongReturnTypeStructure.java") + public void testWrongReturnTypeStructure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongReturnTypeStructure.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("WrongTypeParameterBoundStructure1.java") + public void testWrongTypeParameterBoundStructure1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("WrongValueParameterStructure1.java") + public void testWrongValueParameterStructure1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/error/WrongValueParameterStructure1.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Propagation extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Parameter extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter.java") + public void testDeeplySubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.java") + public void testDeeplySubstitutedClassParameter2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNotVararg.java") + public void testInheritNotVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVararg.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNotVarargInteger.java") + public void testInheritNotVarargInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNotVarargNotNull.java") + public void testInheritNotVarargNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNotVarargPrimitive.java") + public void testInheritNotVarargPrimitive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNullability.java") + public void testInheritNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritNullability.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritVararg.java") + public void testInheritVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVararg.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritVarargInteger.java") + public void testInheritVarargInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargInteger.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritVarargNotNull.java") + public void testInheritVarargNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritVarargPrimitive.java") + public void testInheritVarargPrimitive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Kt3302.java") + public void testKt3302() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/Kt3302.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MutableToReadOnly.java") + public void testMutableToReadOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/MutableToReadOnly.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NotNullToNullable.java") + public void testNotNullToNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NotNullToNullable.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NullableToNotNull.java") + public void testNullableToNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNull.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NullableToNotNullKotlinSignature.java") + public void testNullableToNotNullKotlinSignature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("OverrideWithErasedParameter.java") + public void testOverrideWithErasedParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ReadOnlyToMutable.java") + public void testReadOnlyToMutable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubclassFromGenericAndNot.java") + public void testSubclassFromGenericAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubstitutedClassParameter.java") + public void testSubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubstitutedClassParameters.java") + public void testSubstitutedClassParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Return extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("AddNotNullJavaSubtype.java") + public void testAddNotNullJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AddNotNullSameJavaType.java") + public void testAddNotNullSameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AddNullabilityJavaSubtype.java") + public void testAddNullabilityJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AddNullabilitySameGenericType1.java") + public void testAddNullabilitySameGenericType1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AddNullabilitySameGenericType2.java") + public void testAddNullabilitySameGenericType2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("AddNullabilitySameJavaType.java") + public void testAddNullabilitySameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java"); + doTestCompiledJava(fileName); + } + + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter.java") + public void testDeeplySubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.java") + public void testDeeplySubstitutedClassParameter2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("HalfSubstitutedTypeParameters.java") + public void testHalfSubstitutedTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNullabilityGenericSubclassSimple.java") + public void testInheritNullabilityGenericSubclassSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNullabilityJavaSubtype.java") + public void testInheritNullabilityJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNullabilitySameGenericType.java") + public void testInheritNullabilitySameGenericType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritNullabilitySameJavaType.java") + public void testInheritNullabilitySameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritProjectionKind.java") + public void testInheritProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritProjectionKind.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritReadOnlinessOfArgument.java") + public void testInheritReadOnlinessOfArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritReadOnlinessSameClass.java") + public void testInheritReadOnlinessSameClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritReadOnlinessSubclass.java") + public void testInheritReadOnlinessSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SameProjectionKind.java") + public void testSameProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SameProjectionKind.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubclassFromGenericAndNot.java") + public void testSubclassFromGenericAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubclassOfCollection.java") + public void testSubclassOfCollection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfCollection.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubclassOfMapEntry.java") + public void testSubclassOfMapEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubclassOfMapEntry.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubstitutedClassParameter.java") + public void testSubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubstitutedClassParameters.java") + public void testSubstitutedClassParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/SubstitutedClassParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesConflictingProjectionKinds.java") + public void testTwoSuperclassesConflictingProjectionKinds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferMutability.java") + public void testTwoSuperclassesInvariantAndCovariantInferMutability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferNullability.java") + public void testTwoSuperclassesInvariantAndCovariantInferNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesMutableAndNot.java") + public void testTwoSuperclassesMutableAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesReturnJavaSubtype.java") + public void testTwoSuperclassesReturnJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesReturnSameJavaType.java") + public void testTwoSuperclassesReturnSameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesSupplementNotNull.java") + public void testTwoSuperclassesSupplementNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParamOfClass.java") + public void testTypeParamOfClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParamOfClassSubstituted.java") + public void testTypeParamOfClassSubstituted() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParamOfFun.java") + public void testTypeParamOfFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameter extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/InheritNullability.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoBounds.java") + public void testTwoBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoBounds.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclasses.java") + public void testTwoSuperclasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoTypeParameters.java") + public void testTwoTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("UseParameterAsUpperBound.java") + public void testUseParameterAsUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("UseParameterInUpperBound.java") + public void testUseParameterInUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("UseParameterInUpperBoundWithKotlinSignature.java") + public void testUseParameterInUpperBoundWithKotlinSignature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.java"); + doTestCompiledJava(fileName); + } + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/library") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Library extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/library/LoadIterable.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("LoadIterator.java") + public void testLoadIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/library/LoadIterator.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Max.java") + public void testMax() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/library/Max.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/modality") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Modality extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/modality/ModalityOfFakeOverrides.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/mutability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Mutability extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/mutability/LoadIterable.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("LoadIterableWithConflict.java") + public void testLoadIterableWithConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithConflict.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("LoadIterableWithNullability.java") + public void testLoadIterableWithNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithNullability.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("LoadIterableWithPropagation.java") + public void testLoadIterableWithPropagation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/mutability/LoadIterableWithPropagation.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ReadOnlyExtendsWildcard.java") + public void testReadOnlyExtendsWildcard() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/mutability/ReadOnlyExtendsWildcard.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/notNull") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotNull extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/notNull/NotNullField.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NotNullIntArray.java") + public void testNotNullIntArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/notNull/NotNullIntArray.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NotNullMethod.java") + public void testNotNullMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/notNull/NotNullMethod.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NotNullObjectArray.java") + public void testNotNullObjectArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/notNull/NotNullObjectArray.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NotNullParameter.java") + public void testNotNullParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/notNull/NotNullParameter.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/protectedPackage") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProtectedPackage extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageConstructor.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ProtectedPackageFun.java") + public void testProtectedPackageFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageFun.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ProtectedPackageProperty.java") + public void testProtectedPackageProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/protectedPackage/ProtectedPackageProperty.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/protectedStatic") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProtectedStatic extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/protectedStatic/ConstructorInProtectedStaticNestedClass.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/rendering") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Rendering extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/rendering/Rendering.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/sam") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Sam extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/Comparator.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DifferentParametersCount.java") + public void testDifferentParametersCount() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/DifferentParametersCount.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("FakeStaticOverrides.java") + public void testFakeStaticOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/FakeStaticOverrides.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("FilenameFilter.java") + public void testFilenameFilter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/FilenameFilter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("GenericInterfaceParameterWithSelfBound.java") + public void testGenericInterfaceParameterWithSelfBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParameterWithSelfBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("GenericInterfaceParametersWithBounds.java") + public void testGenericInterfaceParametersWithBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/GenericInterfaceParametersWithBounds.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("GenericMethodParameters.java") + public void testGenericMethodParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/GenericMethodParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InterfaceWithObjectMethod.java") + public void testInterfaceWithObjectMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/InterfaceWithObjectMethod.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Nested.java") + public void testNested() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/Nested.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Runnable.java") + public void testRunnable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/Runnable.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SamSubinterfaceOfTwo.java") + public void testSamSubinterfaceOfTwo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOfTwo.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SamSubinterfaceOverridding.java") + public void testSamSubinterfaceOverridding() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/SamSubinterfaceOverridding.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticOverrides.java") + public void testStaticOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/StaticOverrides.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubstitutedSamInterface.java") + public void testSubstitutedSamInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterface.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubstitutedSamInterfaceSubclassOfBuiltin.java") + public void testSubstitutedSamInterfaceSubclassOfBuiltin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/SubstitutedSamInterfaceSubclassOfBuiltin.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("VarargParameter.java") + public void testVarargParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/VarargParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/sam/adapters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Adapters extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/AmbiguousAdapters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/Basic.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Constructor.java") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/Constructor.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ConstructorWithAnnotations.java") + public void testConstructorWithAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/ConstructorWithAnnotations.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DeepSamLoop.java") + public void testDeepSamLoop() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/DeepSamLoop.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NoSamForClassTypeParameter.java") + public void testNoSamForClassTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForClassTypeParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NoSamForMethodTypeParameter.java") + public void testNoSamForMethodTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/NoSamForMethodTypeParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("NonTrivialFunctionType.java") + public void testNonTrivialFunctionType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/NonTrivialFunctionType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("PrivateSamAdapter.java") + public void testPrivateSamAdapter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/PrivateSamAdapter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SelfAsParameter.java") + public void testSelfAsParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/SelfAsParameter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SeveralSamParameters.java") + public void testSeveralSamParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/SeveralSamParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParameterOfClass.java") + public void testTypeParameterOfClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParameterOfMethod.java") + public void testTypeParameterOfMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfMethod.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TypeParameterOfOuterClass.java") + public void testTypeParameterOfOuterClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/TypeParameterOfOuterClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inheritance extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("AdapterDoesntOverrideDeclaration.java") + public void testAdapterDoesntOverrideDeclaration() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/AdapterDoesntOverrideDeclaration.java"); + doTestCompiledJava(fileName); + } + + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAdapterAndDeclaration.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedAmbiguousAdapters.java") + public void testInheritedAmbiguousAdapters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAmbiguousAdapters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedAndOverriddenAmbiguousAdapters.java") + public void testInheritedAndOverriddenAmbiguousAdapters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedAndOverriddenAmbiguousAdapters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedOverridden.java") + public void testInheritedOverridden() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverridden.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedOverriddenAdapter.java") + public void testInheritedOverriddenAdapter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedOverriddenAdapter.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedSameAdapters.java") + public void testInheritedSameAdapters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdapters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedSameAdaptersWithSubstitution.java") + public void testInheritedSameAdaptersWithSubstitution() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSameAdaptersWithSubstitution.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InheritedSimple.java") + public void testInheritedSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/InheritedSimple.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("OverriddenAmbiguousAdapters.java") + public void testOverriddenAmbiguousAdapters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance/OverriddenAmbiguousAdapters.java"); + doTestCompiledJava(fileName); + } + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SignaturePropagation extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/ArraysInSubtypes.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("MethodTypeParameterErased.java") + public void testMethodTypeParameterErased() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/MethodTypeParameterErased.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawSuperType.java") + public void testRawSuperType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawSuperTypeWithBound.java") + public void testRawSuperTypeWithBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawSuperTypeWithRecursiveBound.java") + public void testRawSuperTypeWithRecursiveBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBound.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("RawSuperTypeWithRecursiveBoundMultipleParameters.java") + public void testRawSuperTypeWithRecursiveBoundMultipleParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("ReturnInnerSubclassOfSupersInner.java") + public void testReturnInnerSubclassOfSupersInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("SubclassWithRawType.java") + public void testSubclassWithRawType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/SubclassWithRawType.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("TwoSuperclassesInconsistentGenericTypes.java") + public void testTwoSuperclassesInconsistentGenericTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/signaturePropagation/TwoSuperclassesInconsistentGenericTypes.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/static") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Static extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/DeeplyInnerClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("DeeplyNestedStatic.java") + public void testDeeplyNestedStatic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/DeeplyNestedStatic.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Enum.java") + public void testEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/Enum.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("InnerClass.java") + public void testInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/InnerClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("Simple.java") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/Simple.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticFinal.java") + public void testStaticFinal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticFinal.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticMembersFromParentClass.java") + public void testStaticMembersFromParentClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClass.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticMembersFromParentClassVisibility.java") + public void testStaticMembersFromParentClassVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentClassVisibility.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticMembersFromParentInterface.java") + public void testStaticMembersFromParentInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersFromParentInterface.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticMembersInEnum.java") + public void testStaticMembersInEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("StaticMembersInEnumFromParents.java") + public void testStaticMembersInEnumFromParents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/static/StaticMembersInEnumFromParents.java"); + doTestCompiledJava(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJava/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractLoadJavaUsingJavacTest { + 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 { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/vararg/VarargInt.java"); + doTestCompiledJava(fileName); + } + + @TestMetadata("VarargString.java") + public void testVarargString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJava/vararg/VarargString.java"); + doTestCompiledJava(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJavaAndKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompiledJavaAndKotlin extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInCompiledJavaAndKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), TargetBackend.ANY, true); + } + + @TestMetadata("MixedPackage.txt") + public void testMixedPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage.txt"); + doTestCompiledJavaAndKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledJavaIncludeObjectMethods") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompiledJavaIncludeObjectMethods extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInCompiledJavaIncludeObjectMethods() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassWithObjectMethod.java") + public void testClassWithObjectMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJavaIncludeObjectMethods/ClassWithObjectMethod.java"); + doTestCompiledJavaIncludeObjectMethods(fileName); + } + + @TestMetadata("EmptyInterface.java") + public void testEmptyInterface() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJavaIncludeObjectMethods/EmptyInterface.java"); + doTestCompiledJavaIncludeObjectMethods(fileName); + } + + @TestMetadata("InterfaceWithObjectMethods.java") + public void testInterfaceWithObjectMethods() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledJavaIncludeObjectMethods/InterfaceWithObjectMethods.java"); + doTestCompiledJavaIncludeObjectMethods(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompiledKotlin extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInCompiledKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AnnotatedAnnotation.kt") + public void testAnnotatedAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AnnotatedMethod.kt") + public void testAnnotatedMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedMethod.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AnnotationInAnnotationArguments.kt") + public void testAnnotationInAnnotationArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/AnnotationInAnnotationArguments.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumArgumentWithCustomToString.kt") + public void testEnumArgumentWithCustomToString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MultiDimensionalArrayMethod.kt") + public void testMultiDimensionalArrayMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrimitiveArrayArguments.kt") + public void testPrimitiveArrayArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/PrimitiveArrayArguments.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SimpleAnnotation.kt") + public void testSimpleAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TargetedAnnotation.kt") + public void testTargetedAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassMembers extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInClassMembers() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassObjectPropertyField.kt") + public void testClassObjectPropertyField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumArgument.kt") + public void testEnumArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumEntry.kt") + public void testEnumEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumEntry.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Getter.kt") + public void testGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertyField.kt") + public void testPropertyField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Setter.kt") + public void testSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Classes extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("AnnotationInClassObject.kt") + public void testAnnotationInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassInClassObject.kt") + public void testClassInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObject.kt") + public void testClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectInStaticNestedClass.kt") + public void testClassObjectInStaticNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObjectInStaticNestedClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DataClass.kt") + public void testDataClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Deprecated.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DollarsInAnnotationName.kt") + public void testDollarsInAnnotationName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumArgument.kt") + public void testEnumArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MultipleAnnotations.kt") + public void testMultipleAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedAnnotation.kt") + public void testNestedAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Retention.kt") + public void testRetention() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WithArgument.kt") + public void testWithArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WithMultipleArguments.kt") + public void testWithMultipleArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageMembers extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInPackageMembers() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumArgument.kt") + public void testEnumArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumArrayArgument.kt") + public void testEnumArrayArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Getter.kt") + public void testGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertyField.kt") + public void testPropertyField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Setter.kt") + public void testSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("StringArrayArgument.kt") + public void testStringArrayArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Parameters extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumConstructor.kt") + public void testEnumConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtensionFunction.kt") + public void testExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtensionFunctionInClass.kt") + public void testExtensionFunctionInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtensionPropertySetter.kt") + public void testExtensionPropertySetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunctionInClass.kt") + public void testFunctionInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunctionInTrait.kt") + public void testFunctionInTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerClassConstructor.kt") + public void testInnerClassConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ManyAnnotations.kt") + public void testManyAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertySetterInClass.kt") + public void testPropertySetterInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TopLevelFunction.kt") + public void testTopLevelFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TopLevelPropertySetter.kt") + public void testTopLevelPropertySetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PropertiesWithoutBackingFields extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Class.kt") + public void testClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObject.kt") + public void testClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtensionsWithSameNameClass.kt") + public void testExtensionsWithSameNameClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtensionsWithSameNamePackage.kt") + public void testExtensionsWithSameNamePackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedTrait.kt") + public void testNestedTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TopLevel.kt") + public void testTopLevel() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TraitClassObject.kt") + public void testTraitClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Types extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ReceiverParameter.kt") + public void testReceiverParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SimpleTypeAnnotation.kt") + public void testSimpleTypeAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SupertypesAndBounds.kt") + public void testSupertypesAndBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeAnnotationWithArguments.kt") + public void testTypeAnnotationWithArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeArgument.kt") + public void testTypeArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/TypeArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeParameterAnnotation.kt") + public void testTypeParameterAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeParameterAnnotationWithArguments.kt") + public void testTypeParameterAnnotationWithArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotationWithArguments.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithUseSiteTarget extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInWithUseSiteTarget() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DelegateTarget.kt") + public void testDelegateTarget() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/DelegateTarget.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FieldTarget.kt") + public void testFieldTarget() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/FieldTarget.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReceiverTarget.kt") + public void testReceiverTarget() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/ReceiverTarget.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/class") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Class extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Class.kt") + public void testClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/Class.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassInParam.kt") + public void testClassInParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassInParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassInnerClass.kt") + public void testClassInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassInnerClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassMemberConflict.kt") + public void testClassMemberConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassMemberConflict.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassOutParam.kt") + public void testClassOutParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassOutParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParam.kt") + public void testClassParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamReferencesParam.kt") + public void testClassParamReferencesParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamReferencesParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamReferencesParam2.kt") + public void testClassParamReferencesParam2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamReferencesParam2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamReferencesSelf.kt") + public void testClassParamReferencesSelf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamReferencesSelf.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamUpperClassBound.kt") + public void testClassParamUpperClassBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamUpperClassBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamUpperClassInterfaceBound.kt") + public void testClassParamUpperClassInterfaceBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamUpperClassInterfaceBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamUpperInterfaceBound.kt") + public void testClassParamUpperInterfaceBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamUpperInterfaceBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassTwoParams.kt") + public void testClassTwoParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassTwoParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassTwoParams2.kt") + public void testClassTwoParams2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassTwoParams2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumWithGenericConstructorParameter.kt") + public void testEnumWithGenericConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/EnumWithGenericConstructorParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("EnumWithPrimitiveConstructorParameter.kt") + public void testEnumWithPrimitiveConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/EnumWithPrimitiveConstructorParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritClassSimple.kt") + public void testInheritClassSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritClassSimple.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritClassWithParam.kt") + public void testInheritClassWithParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritClassWithParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritSubstitutedMethod.kt") + public void testInheritSubstitutedMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritSubstitutedMethod.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritTraitWithFunctionParam.kt") + public void testInheritTraitWithFunctionParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritTraitWithFunctionParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritTraitWithParam.kt") + public void testInheritTraitWithParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritTraitWithParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerClassExtendInnerClass.kt") + public void testInnerClassExtendInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InnerClassExtendInnerClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerGenericClass.kt") + public void testInnerGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InnerGenericClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerTypes.kt") + public void testInnerTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InnerTypes.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NamedObject.kt") + public void testNamedObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NamedObjectInClass.kt") + public void testNamedObjectInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NamedObjectInClassObject.kt") + public void testNamedObjectInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectInClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NamedObjectInNamedObject.kt") + public void testNamedObjectInNamedObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectInNamedObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NamedObjectWithAnotherTopLevelProperty.kt") + public void testNamedObjectWithAnotherTopLevelProperty() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectWithAnotherTopLevelProperty.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NestedClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedClassExtendNestedClass.kt") + public void testNestedClassExtendNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NestedClassExtendNestedClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedGenericClass.kt") + public void testNestedGenericClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NestedGenericClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("RecursiveGeneric.kt") + public void testRecursiveGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/RecursiveGeneric.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SingleAbstractMethod.kt") + public void testSingleAbstractMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/SingleAbstractMethod.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/Trait.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaBean extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInJavaBean() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DifferentGetterAndSetter.kt") + public void testDifferentGetterAndSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/DifferentGetterAndSetter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("JavaBeanAbstractGetter.kt") + public void testJavaBeanAbstractGetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanAbstractGetter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("JavaBeanVal.kt") + public void testJavaBeanVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("JavaBeanVar.kt") + public void testJavaBeanVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("JavaBeanVarOfGenericType.kt") + public void testJavaBeanVarOfGenericType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanVarOfGenericType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSetters.kt") + public void testTwoSetters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/TwoSetters.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/classFun") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassFun extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInClassFun() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassInParamUsedInFun.kt") + public void testClassInParamUsedInFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/ClassInParamUsedInFun.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassParamUsedInFun.kt") + public void testClassParamUsedInFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/ClassParamUsedInFun.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunDelegationToTraitImpl.kt") + public void testFunDelegationToTraitImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/FunDelegationToTraitImpl.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunInParamSuper.kt") + public void testFunInParamSuper() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/FunInParamSuper.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TraitOpenFun.kt") + public void testTraitOpenFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/TraitOpenFun.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/classObject") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassObject extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInClassObject() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassObjectDeclaresVal.kt") + public void testClassObjectDeclaresVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectDeclaresVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectDeclaresVar.kt") + public void testClassObjectDeclaresVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectDeclaresVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectDefaultVisibility.kt") + public void testClassObjectDefaultVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectDefaultVisibility.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectExplicitVisibility.kt") + public void testClassObjectExplicitVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectExplicitVisibility.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectExtendsTrait.kt") + public void testClassObjectExtendsTrait() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectExtendsTrait.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectExtendsTraitWithTP.kt") + public void testClassObjectExtendsTraitWithTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectExtendsTraitWithTP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("classObjectInClassStaticFields.kt") + public void testClassObjectInClassStaticFields() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/classObjectInClassStaticFields.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("classObjectInTraitStaticFields.kt") + public void testClassObjectInTraitStaticFields() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/classObjectInTraitStaticFields.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObjectPropertyInClass.kt") + public void testClassObjectPropertyInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectPropertyInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Delegation.kt") + public void testDelegation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/Delegation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerClassInClassObject.kt") + public void testInnerClassInClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/InnerClassInClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NamedClassObject.kt") + public void testNamedClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/NamedClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SimpleClassObject.kt") + public void testSimpleClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/SimpleClassObject.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/constructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Constructor extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Constructor0.kt") + public void testConstructor0() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor0.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Constructor1.kt") + public void testConstructor1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor1.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Constructor1WithParamDefaultValue.kt") + public void testConstructor1WithParamDefaultValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor1WithParamDefaultValue.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Constructor2WithOneParamDefaultValue.kt") + public void testConstructor2WithOneParamDefaultValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor2WithOneParamDefaultValue.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorCollectionParameter.kt") + public void testConstructorCollectionParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorCollectionParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorGenericDeep.kt") + public void testConstructorGenericDeep() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorGenericDeep.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorGenericSimple.kt") + public void testConstructorGenericSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorGenericSimple.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorGenericUpperBound.kt") + public void testConstructorGenericUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorGenericUpperBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithTwoDefArgs.kt") + public void testConstructorWithTwoDefArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoDefArgs.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithTwoTypeParameters.kt") + public void testConstructorWithTwoTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoTypeParameters.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithTwoTypeParametersAndOneIntValueParameter.kt") + public void testConstructorWithTwoTypeParametersAndOneIntValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoTypeParametersAndOneIntValueParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithTwoTypeParametersAndOnePValueParameter.kt") + public void testConstructorWithTwoTypeParametersAndOnePValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoTypeParametersAndOnePValueParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithTypeParameter.kt") + public void testConstructorWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTypeParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithTypeParametersEAndOnePValueParameter.kt") + public void testConstructorWithTypeParametersEAndOnePValueParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTypeParametersEAndOnePValueParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerClassConstructorWithDefArgs.kt") + public void testInnerClassConstructorWithDefArgs() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/InnerClassConstructorWithDefArgs.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrivateConstructor1WithParamDefaultValue.kt") + public void testPrivateConstructor1WithParamDefaultValue() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/PrivateConstructor1WithParamDefaultValue.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInVararg() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ConstructorNonLastVararg.kt") + public void testConstructorNonLastVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg/ConstructorNonLastVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorVararg.kt") + public void testConstructorVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg/ConstructorVararg.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/coroutines") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Coroutines extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInCoroutines() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Basic.kt") + public void testBasic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/coroutines/Basic.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/dataClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DataClass extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInDataClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("MixedComponents.kt") + public void testMixedComponents() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/MixedComponents.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("OneVal.kt") + public void testOneVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/OneVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoVals.kt") + public void testTwoVals() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/TwoVals.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoVars.kt") + public void testTwoVars() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/TwoVars.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInEnum() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("enumVisibility.kt") + public void testEnumVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/enumVisibility.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("enumWithConstuctor.kt") + public void testEnumWithConstuctor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/enumWithConstuctor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("enumWithInnerClasses.kt") + public void testEnumWithInnerClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/enumWithInnerClasses.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("innerEnum.kt") + public void testInnerEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/innerEnum.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("innerEnumExistingClassObject.kt") + public void testInnerEnumExistingClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/innerEnumExistingClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/simpleEnum.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FromLoadJava extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInFromLoadJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ArrayTypeVariance.kt") + public void testArrayTypeVariance() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ArrayTypeVariance.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassDoesNotOverrideMethod.kt") + public void testClassDoesNotOverrideMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassObject.kt") + public void testClassObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("classObjectAnnotation.kt") + public void testClassObjectAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithConstVal.kt") + public void testClassWithConstVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithConstVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithTypeP.kt") + public void testClassWithTypeP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypeP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithTypePExtendsIterableP.kt") + public void testClassWithTypePExtendsIterableP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithTypePP.kt") + public void testClassWithTypePP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithTypePRefNext.kt") + public void testClassWithTypePRefNext() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePRefNext.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithTypePRefSelf.kt") + public void testClassWithTypePRefSelf() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePRefSelf.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassWithTypePRefSelfAndClass.kt") + public void testClassWithTypePRefSelfAndClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePRefSelfAndClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/enum.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FieldAsVar.kt") + public void testFieldAsVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/FieldAsVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FieldOfArrayType.kt") + public void testFieldOfArrayType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/FieldOfArrayType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FinalFieldAsVal.kt") + public void testFinalFieldAsVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/FinalFieldAsVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("genericFunction.kt") + public void testGenericFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/genericFunction.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypes.kt") + public void testInheritMethodsDifferentReturnTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/InheritMethodsDifferentReturnTypes.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypesGeneric.kt") + public void testInheritMethodsDifferentReturnTypesGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/InheritMethodsDifferentReturnTypesGeneric.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InnerClass.kt") + public void testInnerClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/InnerClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodTypePOneUpperBound.kt") + public void testMethodTypePOneUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodTypePOneUpperBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodTypePTwoUpperBounds.kt") + public void testMethodTypePTwoUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodTypePTwoUpperBounds.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithTypeP.kt") + public void testMethodWithTypeP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodWithTypeP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithTypePP.kt") + public void testMethodWithTypePP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodWithTypePP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithTypePRefClassP.kt") + public void testMethodWithTypePRefClassP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodWithTypePRefClassP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethosWithPRefTP.kt") + public void testMethosWithPRefTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethosWithPRefTP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MyException.kt") + public void testMyException() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MyException.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/NestedClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("objectInClass.kt") + public void testObjectInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/objectInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("objectMembers.kt") + public void testObjectMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/objectMembers.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("packageLevelObject.kt") + public void testPackageLevelObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/packageLevelObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("RemoveRedundantProjectionKind.kt") + public void testRemoveRedundantProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/RemoveRedundantProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/Simple.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoFields.kt") + public void testTwoFields() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/TwoFields.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("UnboundWildcard.kt") + public void testUnboundWildcard() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/UnboundWildcard.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinSignature extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("AllBoundsInWhen.kt") + public void testAllBoundsInWhen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/AllBoundsInWhen.kt"); + doTestCompiledKotlin(fileName); + } + + public void testAllFilesPresentInKotlinSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ArrayType.kt") + public void testArrayType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ArrayType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithNewTypeParams.kt") + public void testConstructorWithNewTypeParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithNewTypeParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithParentTypeParams.kt") + public void testConstructorWithParentTypeParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithParentTypeParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithSeveralParams.kt") + public void testConstructorWithSeveralParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithSeveralParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ConstructorWithoutParams.kt") + public void testConstructorWithoutParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithoutParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("CustomProjectionKind.kt") + public void testCustomProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/CustomProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithFunctionTypes.kt") + public void testMethodWithFunctionTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithFunctionTypes.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithGenerics.kt") + public void testMethodWithGenerics() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithGenerics.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithMappedClasses.kt") + public void testMethodWithMappedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithMappedClasses.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithTypeParameters.kt") + public void testMethodWithTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithTypeParameters.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MethodWithVararg.kt") + public void testMethodWithVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertyArrayTypes.kt") + public void testPropertyArrayTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/PropertyArrayTypes.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertyComplexTypes.kt") + public void testPropertyComplexTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/PropertyComplexTypes.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertySimpleType.kt") + public void testPropertySimpleType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/PropertySimpleType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("StarProjection.kt") + public void testStarProjection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/StarProjection.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Error extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("AddingNullability.kt") + public void testAddingNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/AddingNullability.kt"); + doTestCompiledKotlin(fileName); + } + + public void testAllFilesPresentInError() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ConflictingProjectionKind.kt") + public void testConflictingProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ConflictingProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExplicitFieldGettersAndSetters.kt") + public void testExplicitFieldGettersAndSetters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtraUpperBound.kt") + public void testExtraUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ExtraUpperBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MissingUpperBound.kt") + public void testMissingUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/MissingUpperBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NoFieldTypeRef.kt") + public void testNoFieldTypeRef() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/NoFieldTypeRef.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NotVarargReplacedWithVararg.kt") + public void testNotVarargReplacedWithVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/NotVarargReplacedWithVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("RedundantProjectionKind.kt") + public void testRedundantProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/RedundantProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReturnTypeMissing.kt") + public void testReturnTypeMissing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ReturnTypeMissing.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SyntaxError.kt") + public void testSyntaxError() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/SyntaxError.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SyntaxErrorInFieldAnnotation.kt") + public void testSyntaxErrorInFieldAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("VarargReplacedWithNotVararg.kt") + public void testVarargReplacedWithNotVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/VarargReplacedWithNotVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongFieldInitializer.kt") + public void testWrongFieldInitializer() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongFieldInitializer.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongFieldMutability.kt") + public void testWrongFieldMutability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongFieldMutability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongFieldName.kt") + public void testWrongFieldName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongFieldName.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongMethodName.kt") + public void testWrongMethodName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongMethodName.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongProjectionKind.kt") + public void testWrongProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongReturnTypeStructure.kt") + public void testWrongReturnTypeStructure() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongReturnTypeStructure.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongTypeName1.kt") + public void testWrongTypeName1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeName1.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongTypeName2.kt") + public void testWrongTypeName2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeName2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongTypeName3.kt") + public void testWrongTypeName3() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeName3.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongTypeParameterBoundStructure1.kt") + public void testWrongTypeParameterBoundStructure1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongTypeParameterBoundStructure2.kt") + public void testWrongTypeParameterBoundStructure2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongTypeParametersCount.kt") + public void testWrongTypeParametersCount() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeParametersCount.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongValueParameterStructure1.kt") + public void testWrongValueParameterStructure1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongValueParameterStructure1.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongValueParameterStructure2.kt") + public void testWrongValueParameterStructure2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongValueParameterStructure2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("WrongValueParametersCount.kt") + public void testWrongValueParametersCount() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongValueParametersCount.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Propagation extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInPropagation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("PropagateTypeArgumentNullable.kt") + public void testPropagateTypeArgumentNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Parameter extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ChangeProjectionKind1.kt") + public void testChangeProjectionKind1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ChangeProjectionKind2.kt") + public void testChangeProjectionKind2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter.kt") + public void testDeeplySubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.kt") + public void testDeeplySubstitutedClassParameter2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritMutability.kt") + public void testInheritMutability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritMutability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNotVararg.kt") + public void testInheritNotVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNotVarargInteger.kt") + public void testInheritNotVarargInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNotVarargNotNull.kt") + public void testInheritNotVarargNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNotVarargPrimitive.kt") + public void testInheritNotVarargPrimitive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNullability.kt") + public void testInheritNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNullability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritProjectionKind.kt") + public void testInheritProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritReadOnliness.kt") + public void testInheritReadOnliness() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritReadOnliness.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritVararg.kt") + public void testInheritVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritVarargInteger.kt") + public void testInheritVarargInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritVarargNotNull.kt") + public void testInheritVarargNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritVarargPrimitive.kt") + public void testInheritVarargPrimitive() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Kt3302.kt") + public void testKt3302() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/Kt3302.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("MutableToReadOnly.kt") + public void testMutableToReadOnly() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NotNullToNullable.kt") + public void testNotNullToNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NotNullToNullable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NullableToNotNull.kt") + public void testNullableToNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NullableToNotNullKotlinSignature.kt") + public void testNullableToNotNullKotlinSignature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("OverrideWithErasedParameter.kt") + public void testOverrideWithErasedParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReadOnlyToMutable.kt") + public void testReadOnlyToMutable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubclassFromGenericAndNot.kt") + public void testSubclassFromGenericAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubstitutedClassParameter.kt") + public void testSubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubstitutedClassParameters.kt") + public void testSubstitutedClassParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Return extends AbstractLoadJavaUsingJavacTest { + @TestMetadata("AddNotNullJavaSubtype.kt") + public void testAddNotNullJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AddNotNullSameJavaType.kt") + public void testAddNotNullSameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AddNullabilityJavaSubtype.kt") + public void testAddNullabilityJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AddNullabilitySameGenericType1.kt") + public void testAddNullabilitySameGenericType1() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AddNullabilitySameGenericType2.kt") + public void testAddNullabilitySameGenericType2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AddNullabilitySameJavaType.kt") + public void testAddNullabilitySameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt"); + doTestCompiledKotlin(fileName); + } + + public void testAllFilesPresentInReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("CantMakeImmutableInSubclass.kt") + public void testCantMakeImmutableInSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter.kt") + public void testDeeplySubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.kt") + public void testDeeplySubstitutedClassParameter2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("HalfSubstitutedTypeParameters.kt") + public void testHalfSubstitutedTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNullabilityGenericSubclassSimple.kt") + public void testInheritNullabilityGenericSubclassSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNullabilityJavaSubtype.kt") + public void testInheritNullabilityJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNullabilitySameGenericType.kt") + public void testInheritNullabilitySameGenericType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNullabilitySameJavaType.kt") + public void testInheritNullabilitySameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritProjectionKind.kt") + public void testInheritProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritReadOnlinessOfArgument.kt") + public void testInheritReadOnlinessOfArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritReadOnlinessSameClass.kt") + public void testInheritReadOnlinessSameClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritReadOnlinessSubclass.kt") + public void testInheritReadOnlinessSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SameProjectionKind.kt") + public void testSameProjectionKind() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SameProjectionKind.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubclassFromGenericAndNot.kt") + public void testSubclassFromGenericAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubclassOfCollection.kt") + public void testSubclassOfCollection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubclassOfMapEntry.kt") + public void testSubclassOfMapEntry() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfMapEntry.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubstitutedClassParameter.kt") + public void testSubstitutedClassParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SubstitutedClassParameters.kt") + public void testSubstitutedClassParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesConflictingProjectionKinds.kt") + public void testTwoSuperclassesConflictingProjectionKinds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferMutability.kt") + public void testTwoSuperclassesInvariantAndCovariantInferMutability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferNullability.kt") + public void testTwoSuperclassesInvariantAndCovariantInferNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesMutableAndNot.kt") + public void testTwoSuperclassesMutableAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesReturnJavaSubtype.kt") + public void testTwoSuperclassesReturnJavaSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesReturnSameJavaType.kt") + public void testTwoSuperclassesReturnSameJavaType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclassesSupplementNotNull.kt") + public void testTwoSuperclassesSupplementNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeParamOfClass.kt") + public void testTypeParamOfClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeParamOfClassSubstituted.kt") + public void testTypeParamOfClassSubstituted() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TypeParamOfFun.kt") + public void testTypeParamOfFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameter extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInTypeParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("InheritMutability.kt") + public void testInheritMutability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/InheritMutability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritNullability.kt") + public void testInheritNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/InheritNullability.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritReadOnliness.kt") + public void testInheritReadOnliness() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/InheritReadOnliness.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoBounds.kt") + public void testTwoBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/TwoBounds.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoSuperclasses.kt") + public void testTwoSuperclasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TwoTypeParameters.kt") + public void testTwoTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("UseParameterAsUpperBound.kt") + public void testUseParameterAsUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("UseParameterInUpperBound.kt") + public void testUseParameterInUpperBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("UseParameterInUpperBoundWithKotlinSignature.kt") + public void testUseParameterInUpperBoundWithKotlinSignature() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.kt"); + doTestCompiledKotlin(fileName); + } + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Library extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInLibrary() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("LoadIterable.kt") + public void testLoadIterable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library/LoadIterable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("LoadIterator.kt") + public void testLoadIterator() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library/LoadIterator.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Max.kt") + public void testMax() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library/Max.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Modality extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInModality() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ModalityOfFakeOverrides.kt") + public void testModalityOfFakeOverrides() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotNull extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInNotNull() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("NotNullField.kt") + public void testNotNullField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullField.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NotNullIntArray.kt") + public void testNotNullIntArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullIntArray.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NotNullMethod.kt") + public void testNotNullMethod() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullMethod.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NotNullObjectArray.kt") + public void testNotNullObjectArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullObjectArray.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NotNullParameter.kt") + public void testNotNullParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullParameter.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Fun extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInFun() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Assert.kt") + public void testAssert() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/Assert.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("DeclaredMemberOverridesDelegated.kt") + public void testDeclaredMemberOverridesDelegated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/DeclaredMemberOverridesDelegated.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InfixKeyword.kt") + public void testInfixKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InfixKeyword.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypesAndVisibilities.kt") + public void testInheritMethodsDifferentReturnTypesAndVisibilities() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InheritMethodsDifferentReturnTypesAndVisibilities.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritValAndVar.kt") + public void testInheritValAndVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InheritValAndVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InheritValsDifferentTypes.kt") + public void testInheritValsDifferentTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InheritValsDifferentTypes.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NoSamAdapter.kt") + public void testNoSamAdapter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/NoSamAdapter.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NoSamConstructor.kt") + public void testNoSamConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/NoSamConstructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("OperatorKeyword.kt") + public void testOperatorKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/OperatorKeyword.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropagateDeepSubclass.kt") + public void testPropagateDeepSubclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/PropagateDeepSubclass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropagateSubclassOfComparable.kt") + public void testPropagateSubclassOfComparable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/PropagateSubclassOfComparable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class GenericWithTypeVariables extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("FunGenericParam.kt") + public void testFunGenericParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunGenericParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamParam.kt") + public void testFunParamParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamParamErased.kt") + public void testFunParamParamErased() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamParamErased.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamReferencesParam.kt") + public void testFunParamReferencesParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamReferencesParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamTwoUpperBounds.kt") + public void testFunParamTwoUpperBounds() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamTwoUpperBounds.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamUpperClassBound.kt") + public void testFunParamUpperClassBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamUpperClassBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamUpperClassInterfaceBound.kt") + public void testFunParamUpperClassInterfaceBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamUpperClassInterfaceBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamUpperInterfaceBound.kt") + public void testFunParamUpperInterfaceBound() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamUpperInterfaceBound.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamVaragParam.kt") + public void testFunParamVaragParam() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamVaragParam.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunTwoTypeParams.kt") + public void testFunTwoTypeParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunTwoTypeParams.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class GenericWithoutTypeVariables extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("FunClassParamNotNull.kt") + public void testFunClassParamNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/FunClassParamNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunClassParamNullable.kt") + public void testFunClassParamNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/FunClassParamNullable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamNullable.kt") + public void testFunParamNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/FunParamNullable.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReturnTypeClassParamNotNull.kt") + public void testReturnTypeClassParamNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/ReturnTypeClassParamNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReturnTypeClassParamNullable.kt") + public void testReturnTypeClassParamNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/ReturnTypeClassParamNullable.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonGeneric extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInNonGeneric() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassFun.kt") + public void testClassFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFun.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassFunGetFoo.kt") + public void testClassFunGetFoo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFunGetFoo.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassFunGetFooSetFoo.kt") + public void testClassFunGetFooSetFoo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFunGetFooSetFoo.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassFunSetFoo.kt") + public void testClassFunSetFoo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFunSetFoo.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtFun.kt") + public void testExtFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ExtFun.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtFunInClass.kt") + public void testExtFunInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ExtFunInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunDefaultArg.kt") + public void testFunDefaultArg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunDefaultArg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunParamNotNull.kt") + public void testFunParamNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunParamNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunVarargInt.kt") + public void testFunVarargInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunVarargInt.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("FunVarargInteger.kt") + public void testFunVarargInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunVarargInteger.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ModifierAbstract.kt") + public void testModifierAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ModifierAbstract.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ModifierOpen.kt") + public void testModifierOpen() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ModifierOpen.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NsFun.kt") + public void testNsFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/NsFun.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NsFunGetFoo.kt") + public void testNsFunGetFoo() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/NsFunGetFoo.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReturnTypeNotNull.kt") + public void testReturnTypeNotNull() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ReturnTypeNotNull.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ReturnTypeNullable.kt") + public void testReturnTypeNullable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ReturnTypeNullable.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInVararg() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("nonLastVararg.kt") + public void testNonLastVararg() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg/nonLastVararg.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("VarargInt.kt") + public void testVarargInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg/VarargInt.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("VarargString.kt") + public void testVarargString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg/VarargString.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/inline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inline extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("inlineFunction.kt") + public void testInlineFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/inline/inlineFunction.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MemberOrder extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInMemberOrder() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callablesNameClash.kt") + public void testCallablesNameClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/callablesNameClash.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("enumEntries.kt") + public void testEnumEntries() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/enumEntries.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("extensionMembers.kt") + public void testExtensionMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/extensionMembers.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("extensionPropertiesNameClash.kt") + public void testExtensionPropertiesNameClash() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/extensionPropertiesNameClash.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("innerClasses.kt") + public void testInnerClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/innerClasses.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("topLevelCallables.kt") + public void testTopLevelCallables() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/topLevelCallables.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/nested") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Nested extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInNested() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("deepInnerGeneric.kt") + public void testDeepInnerGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/nested/deepInnerGeneric.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("innerClassReferencesOuterTP.kt") + public void testInnerClassReferencesOuterTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/nested/innerClassReferencesOuterTP.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("membersReferenceOuterTP.kt") + public void testMembersReferenceOuterTP() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/nested/membersReferenceOuterTP.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PlatformTypes extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInPlatformTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("notnullTypeArgument.kt") + public void testNotnullTypeArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("nullableTypeArgument.kt") + public void testNullableTypeArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/prop") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Prop extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInProp() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassVal.kt") + public void testClassVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ClassVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassValAbstract.kt") + public void testClassValAbstract() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ClassValAbstract.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassVar.kt") + public void testClassVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ClassVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("CollectionSize.kt") + public void testCollectionSize() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/CollectionSize.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Const.kt") + public void testConst() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/Const.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Constants.kt") + public void testConstants() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/Constants.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValClass.kt") + public void testExtValClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValInClass.kt") + public void testExtValInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValInt.kt") + public void testExtValInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValInt.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValIntCharSequence.kt") + public void testExtValIntCharSequence() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntCharSequence.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValIntCharSequenceQ.kt") + public void testExtValIntCharSequenceQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntCharSequenceQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValIntListQOfIntInClass.kt") + public void testExtValIntListQOfIntInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntListQOfIntInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValIntTInClass.kt") + public void testExtValIntTInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntTInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValIntTQInClass.kt") + public void testExtValIntTQInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntTQInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValTIntInClass.kt") + public void testExtValTIntInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValTIntInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarClass.kt") + public void testExtVarClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarInClass.kt") + public void testExtVarInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarInt.kt") + public void testExtVarInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarInt.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarIntTInClass.kt") + public void testExtVarIntTInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarIntTInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarIntTQInClass.kt") + public void testExtVarIntTQInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarIntTQInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarMapPQInt.kt") + public void testExtVarMapPQInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarMapPQInt.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarTIntInClass.kt") + public void testExtVarTIntInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarTIntInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarTQIntInClass.kt") + public void testExtVarTQIntInClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarTQIntInClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarl.kt") + public void testExtVarl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarl.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NsVal.kt") + public void testNsVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/NsVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NsVar.kt") + public void testNsVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/NsVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("OverrideClassVal.kt") + public void testOverrideClassVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/OverrideClassVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("OverrideTraitVal.kt") + public void testOverrideTraitVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/OverrideTraitVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropFromSuperclass.kt") + public void testPropFromSuperclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/PropFromSuperclass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TraitFinalVar.kt") + public void testTraitFinalVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/TraitFinalVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TraitOpenVal.kt") + public void testTraitOpenVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/TraitOpenVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("VarDelegationToTraitImpl.kt") + public void testVarDelegationToTraitImpl() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/VarDelegationToTraitImpl.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("VarWithDelegated.kt") + public void testVarWithDelegated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/VarWithDelegated.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultAccessors extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInDefaultAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassVal.kt") + public void testClassVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassValParams.kt") + public void testClassValParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassValParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassValWithGet.kt") + public void testClassValWithGet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassValWithGet.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassVar.kt") + public void testClassVar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassVarModality.kt") + public void testClassVarModality() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarModality.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassVarParams.kt") + public void testClassVarParams() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarParams.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassVarWithGet.kt") + public void testClassVarWithGet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarWithGet.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ClassVarWithSet.kt") + public void testClassVarWithSet() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarWithSet.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtValLong.kt") + public void testExtValLong() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ExtValLong.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ExtVarLong.kt") + public void testExtVarLong() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ExtVarLong.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/type") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Type extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Any.kt") + public void testAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Any.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("AnyQ.kt") + public void testAnyQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/AnyQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ArrayOfInNumber.kt") + public void testArrayOfInNumber() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfInNumber.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ArrayOfInt.kt") + public void testArrayOfInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfInt.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ArrayOfInteger.kt") + public void testArrayOfInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfInteger.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ArrayOfOutNumber.kt") + public void testArrayOfOutNumber() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfOutNumber.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ArrayOfOutT.kt") + public void testArrayOfOutT() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfOutT.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ArrayOfString.kt") + public void testArrayOfString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfString.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Function1IntString.kt") + public void testFunction1IntString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Function1IntString.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Int.kt") + public void testInt() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Int.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("IntArray.kt") + public void testIntArray() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/IntArray.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("IntQ.kt") + public void testIntQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/IntQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlInteger.kt") + public void testJlInteger() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlInteger.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlIntegerQ.kt") + public void testJlIntegerQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlIntegerQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlNumber.kt") + public void testJlNumber() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlNumber.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlObject.kt") + public void testJlObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlObject.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlObjectQ.kt") + public void testJlObjectQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlObjectQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlString.kt") + public void testJlString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlString.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("jlStringQ.kt") + public void testJlStringQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlStringQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ListOfAny.kt") + public void testListOfAny() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfAny.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ListOfAnyQ.kt") + public void testListOfAnyQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfAnyQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ListOfStar.kt") + public void testListOfStar() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfStar.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ListOfString.kt") + public void testListOfString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfString.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("ListOfjlString.kt") + public void testListOfjlString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfjlString.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Nothing.kt") + public void testNothing() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Nothing.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("NothingQ.kt") + public void testNothingQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/NothingQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("platform.kt") + public void testPlatform() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/platform.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("String.kt") + public void testString() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/String.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("StringQ.kt") + public void testStringQ() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/StringQ.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("SuspendFunction.kt") + public void testSuspendFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/SuspendFunction.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Unit.kt") + public void testUnit() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Unit.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/typealias") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Typealias extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInTypealias() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/typealias/Annotations.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Basic.kt") + public void testBasic() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/typealias/Basic.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("Generic.kt") + public void testGeneric() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/typealias/Generic.kt"); + doTestCompiledKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/visibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Visibility extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInVisibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("InternalClass.kt") + public void testInternalClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InternalConstructor.kt") + public void testInternalConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalConstructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("InternalTopLevelMembers.kt") + public void testInternalTopLevelMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalTopLevelMembers.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrivateClass.kt") + public void testPrivateClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrivateClassMembers.kt") + public void testPrivateClassMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrivateToThis.kt") + public void testPrivateToThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateToThis.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrivateTopLevelFun.kt") + public void testPrivateTopLevelFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PrivateTopLevelVal.kt") + public void testPrivateTopLevelVal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelVal.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertyInConstructor.kt") + public void testPropertyInConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PropertyInConstructor.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("PropertyInConstructorExplicitVisibility.kt") + public void testPropertyInConstructorExplicitVisibility() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PropertyInConstructorExplicitVisibility.kt"); + doTestCompiledKotlin(fileName); + } + + @TestMetadata("TopLevelVarWithPrivateSetter.kt") + public void testTopLevelVarWithPrivateSetter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/TopLevelVarWithPrivateSetter.kt"); + doTestCompiledKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CompiledKotlinWithStdlib extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInCompiledKotlinWithStdlib() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("ConstValInMultifileClass.kt") + public void testConstValInMultifileClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations/ConstValInMultifileClass.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Coroutines extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInCoroutines() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotatedSuspendFun.kt") + public void testAnnotatedSuspendFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines/annotatedSuspendFun.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Mutability extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInMutability() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("LoadIterable.kt") + public void testLoadIterable() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability/LoadIterable.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + + @TestMetadata("LoadIterableWithConflict.kt") + public void testLoadIterableWithConflict() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability/LoadIterableWithConflict.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + + @TestMetadata("LoadIterableWithNullability.kt") + public void testLoadIterableWithNullability() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability/LoadIterableWithNullability.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + + @TestMetadata("LoadIterableWithPropagation.kt") + public void testLoadIterableWithPropagation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability/LoadIterableWithPropagation.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PlatformNames extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInPlatformNames() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("functionName.kt") + public void testFunctionName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.kt"); + doTestCompiledKotlinWithStdlib(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaAgainstKotlin extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SamAdapters extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInSamAdapters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), TargetBackend.ANY, true); + } + + @TestMetadata("InheritAmbguousSamAdaptersInKotlin.txt") + public void testInheritAmbguousSamAdaptersInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("InheritSamAdapterInKotlin.txt") + public void testInheritSamAdapterInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("OverrideSamAdapterInKotlin.txt") + public void testOverrideSamAdapterInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("SamAdapterForInheritedFromKotlin.txt") + public void testSamAdapterForInheritedFromKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("SamAdapterForOverriddenFromKotlin.txt") + public void testSamAdapterForOverriddenFromKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin.txt"); + doTestJavaAgainstKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SignaturePropagation extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInSignaturePropagation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), TargetBackend.ANY, true); + } + + @TestMetadata("DeepSubclassingKotlinInJava.txt") + public void testDeepSubclassingKotlinInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("InheritExtensionAndNot.txt") + public void testInheritExtensionAndNot() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("InheritExtensionFunction.txt") + public void testInheritExtensionFunction() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("SubclassFromTraitImplementation.txt") + public void testSubclassFromTraitImplementation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("SubclassingKotlinInJava.txt") + public void testSubclassingKotlinInJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava.txt"); + doTestJavaAgainstKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin/visibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Visibility extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInVisibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), TargetBackend.ANY, true); + } + + @TestMetadata("PackageLocal.txt") + public void testPackageLocal() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal.txt"); + doTestJavaAgainstKotlin(fileName); + } + + @TestMetadata("ProtectedPackage.txt") + public void testProtectedPackage() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage.txt"); + doTestJavaAgainstKotlin(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinAgainstCompiledJavaWithKotlin extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInKotlinAgainstCompiledJavaWithKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, false); + } + + @TestMetadata("InheritJavaField.kt") + public void testInheritJavaField() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritJavaField.kt"); + doTestKotlinAgainstCompiledJavaWithKotlin(fileName); + } + + @TestMetadata("InheritParameterName.kt") + public void testInheritParameterName() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/InheritParameterName.kt"); + doTestKotlinAgainstCompiledJavaWithKotlin(fileName); + } + + @TestMetadata("javaRefersToKotlin.kt") + public void testJavaRefersToKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/javaRefersToKotlin.kt"); + doTestKotlinAgainstCompiledJavaWithKotlin(fileName); + } + + @TestMetadata("propagationAgainstDeserializedSuperclass.kt") + public void testPropagationAgainstDeserializedSuperclass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin/propagationAgainstDeserializedSuperclass.kt"); + doTestKotlinAgainstCompiledJavaWithKotlin(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/sourceJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SourceJava extends AbstractLoadJavaUsingJavacTest { + public void testAllFilesPresentInSourceJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), TargetBackend.ANY, true); + } + + @TestMetadata("ClassExtendsTypeParameter.java") + public void testClassExtendsTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/ClassExtendsTypeParameter.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("ErrorTypes.java") + public void testErrorTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/ErrorTypes.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("NullInAnnotation.java") + public void testNullInAnnotation() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/NullInAnnotation.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("ReturnInnerSubclassOfSupersInner.java") + public void testReturnInnerSubclassOfSupersInner() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("ReturnNotSubtype.java") + public void testReturnNotSubtype() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/ReturnNotSubtype.java"); + doTestSourceJava(fileName); + } + + @TestMetadata("WrongNumberOfGenericParameters.java") + public void testWrongNumberOfGenericParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java"); + doTestSourceJava(fileName); + } + } +} diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index c00feebddbd..ca00cfcdf9c 100755 --- a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -164,6 +164,9 @@ import org.jetbrains.kotlin.jvm.runtime.AbstractJvmRuntimeDescriptorLoaderTest import org.jetbrains.kotlin.kapt3.test.AbstractClassFileToSourceStubConverterTest import org.jetbrains.kotlin.kapt3.test.AbstractKotlinKaptContextTest import org.jetbrains.kotlin.kdoc.AbstractKDocLexerTest +import org.jetbrains.kotlin.checkers.javac.* +import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJava8UsingJavacTest +import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJavaUsingJavacTest import org.jetbrains.kotlin.modules.xml.AbstractModuleXmlParserTest import org.jetbrains.kotlin.multiplatform.AbstractMultiPlatformIntegrationTest import org.jetbrains.kotlin.noarg.AbstractBlackBoxCodegenTestForNoArg @@ -207,10 +210,24 @@ fun main(args: Array) { model("codegen/box/diagnostics") } + testClass { + model("diagnostics/tests") + model("codegen/box/diagnostics") + } + + testClass { + model("javac/diagnostics/tests") + model("javac/diagnostics/tests", testClassName = "TestsWithoutJavac", testMethod = "doTestWithoutJavacWrapper") + } + testClass { model("diagnostics/testsWithStdLib") } + testClass { + model("diagnostics/testsWithStdLib") + } + testClass { model("diagnostics/testsWithJsStdLib") } @@ -243,6 +260,10 @@ fun main(args: Array) { model("foreignAnnotations/tests") } + testClass { + model("foreignAnnotations/tests") + } + testClass { model("resolve", extension = "resolve") } @@ -350,6 +371,17 @@ fun main(args: Array) { model("loadJava/sourceJava", extension = "java", testMethod = "doTestSourceJava") } + testClass { + model("loadJava/compiledJava", extension = "java", testMethod = "doTestCompiledJava") + model("loadJava/compiledJavaAndKotlin", extension = "txt", testMethod = "doTestCompiledJavaAndKotlin") + model("loadJava/compiledJavaIncludeObjectMethods", extension = "java", testMethod = "doTestCompiledJavaIncludeObjectMethods") + model("loadJava/compiledKotlin", testMethod = "doTestCompiledKotlin") + model("loadJava/compiledKotlinWithStdlib", testMethod = "doTestCompiledKotlinWithStdlib") + model("loadJava/javaAgainstKotlin", extension = "txt", testMethod = "doTestJavaAgainstKotlin") + model("loadJava/kotlinAgainstCompiledJavaWithKotlin", extension = "kt", testMethod = "doTestKotlinAgainstCompiledJavaWithKotlin", recursive = false) + model("loadJava/sourceJava", extension = "java", testMethod = "doTestSourceJava") + } + testClass { model("loadJava/compiledKotlin") } @@ -474,11 +506,20 @@ fun main(args: Array) { model("foreignAnnotationsJava8/tests") } + testClass { + model("foreignAnnotationsJava8/tests") + } + testClass { model("loadJava8/compiledJava", extension = "java", testMethod = "doTestCompiledJava") model("loadJava8/sourceJava", extension = "java", testMethod = "doTestSourceJava") } + testClass { + model("loadJava8/compiledJava", extension = "java", testMethod = "doTestCompiledJava") + model("loadJava8/sourceJava", extension = "java", testMethod = "doTestSourceJava") + } + testClass { model("resolvedCalls/enhancedSignatures") }