diff --git a/.idea/modules.xml b/.idea/modules.xml index 67a3045b6a7..2230cb7aa4a 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -19,6 +19,7 @@ + @@ -53,4 +54,4 @@ - + \ No newline at end of file diff --git a/compiler/tests/compiler-tests.iml b/compiler/tests/compiler-tests.iml index 159ff881ddd..b190d7eb0d7 100644 --- a/compiler/tests/compiler-tests.iml +++ b/compiler/tests/compiler-tests.iml @@ -17,6 +17,7 @@ + diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt new file mode 100644 index 00000000000..9e45e82ea28 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -0,0 +1,146 @@ +/* + * Copyright 2010-2015 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.runtime + +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo +import org.jetbrains.kotlin.codegen.GeneratedClassLoader +import org.jetbrains.kotlin.codegen.GenerationUtils +import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.jvm.compiler.ExpectedLoadErrorsUtil +import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil +import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader +import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClass +import org.jetbrains.kotlin.load.kotlin.reflect.RuntimeModuleData +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.FqNameUnsafe +import org.jetbrains.kotlin.renderer.DescriptorRenderer +import org.jetbrains.kotlin.renderer.DescriptorRendererBuilder +import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler +import org.jetbrains.kotlin.resolve.scopes.WritableScope.LockLevel +import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl +import org.jetbrains.kotlin.test.ConfigurationKind +import org.jetbrains.kotlin.test.JetTestUtils +import org.jetbrains.kotlin.test.TestCaseWithTmpdir +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.types.TypeSubstitutor +import org.jetbrains.kotlin.utils.sure +import java.io.File + +public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { + class object { + private val renderer = DescriptorRendererBuilder() + .setWithDefinedIn(false) + .setExcludedAnnotationClasses(listOf( + ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME, + "kotlin.deprecated", + "kotlin.data", + "org.jetbrains.annotations.NotNull", + "org.jetbrains.annotations.Nullable", + "org.jetbrains.annotations.Mutable", + "org.jetbrains.annotations.ReadOnly" + ).map { FqName(it) }) + .setOverrideRenderingPolicy(DescriptorRenderer.OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE) + .setIncludeSynthesizedParameterNames(false) + .setIncludePropertyConstant(false) + .setVerbose(true) + .build() + } + + protected fun doTest(ktFileName: String) { + val ktFile = File(ktFileName) + + val environment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.ALL) + val jetFile = JetTestUtils.createFile(ktFileName, FileUtil.loadFile(ktFile, true), environment.getProject()) + val classFileFactory = GenerationUtils.compileFileGetClassFileFactoryForTest(jetFile) + val classLoader = GeneratedClassLoader(classFileFactory, null, ForTestCompileRuntime.runtimeJarForTests().toURI().toURL()) + + classFileFactory.writeAllTo(tmpdir) + + val module = RuntimeModuleData.create(classLoader).module + + // Since runtime package view descriptor doesn't support getAllDescriptors(), we construct a synthetic package view here. + // It has in its scope descriptors for all the classes and top level members generated by the compiler + val actual = object : PackageViewDescriptor { + val scope = WritableScopeImpl(JetScope.Empty, this, RedeclarationHandler.THROW_EXCEPTION, "runtime descriptor loader test") + + override fun getFqName() = LoadDescriptorUtil.TEST_PACKAGE_FQNAME + override fun getMemberScope() = scope + override fun getModule() = module + override fun accept(visitor: DeclarationDescriptorVisitor, data: D): R = + visitor.visitPackageViewDescriptor(this, data) + + override fun getContainingDeclaration() = throw UnsupportedOperationException() + override fun getOriginal() = throw UnsupportedOperationException() + override fun substitute(substitutor: TypeSubstitutor) = throw UnsupportedOperationException() + override fun acceptVoid(visitor: DeclarationDescriptorVisitor?) = throw UnsupportedOperationException() + override fun getAnnotations() = throw UnsupportedOperationException() + override fun getName() = throw UnsupportedOperationException() + } + + val scope = actual.getMemberScope() + scope.changeLockLevel(LockLevel.BOTH) + + for (outputFile in classLoader.getAllGeneratedFiles()) { + val className = outputFile.relativePath.substringBeforeLast(".class").replace('/', '.').replace('\\', '.') + + val klass = classLoader.loadClass(className).sure("Couldn't load class $className") + + when (ReflectKotlinClass(klass).getClassHeader().kind) { + KotlinClassHeader.Kind.PACKAGE_FACADE -> { + val packageView = module.getPackage(actual.getFqName()) ?: error("Couldn't resolve package ${actual.getFqName()}") + for (descriptor in packageView.getMemberScope().getAllDescriptors()) { + when (descriptor) { + is FunctionDescriptor -> scope.addFunctionDescriptor(descriptor) + is PropertyDescriptor -> scope.addPropertyDescriptor(descriptor) + } + } + } + KotlinClassHeader.Kind.CLASS -> { + val classDescriptor = + resolveClassByFqNameInModule(module, FqNameUnsafe(className)).sure("Couldn't resolve class $className") + if (classDescriptor.getContainingDeclaration() is PackageFragmentDescriptor) { + scope.addClassifierDescriptor(classDescriptor) + } + } + } + } + + val expected = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot(tmpdir, getTestRootDisposable(), + ConfigurationKind.ALL) + val configuration = RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT + .checkPrimaryConstructors(true) + .checkPropertyAccessors(true) + .withRenderer(renderer) + RecursiveDescriptorComparator.validateAndCompareDescriptors(expected.first, actual, configuration, null) + } + + private fun resolveClassByFqNameInModule(module: ModuleDescriptor, fqName: FqNameUnsafe): ClassDescriptor? { + if (fqName.isRoot()) return null + + if (fqName.isSafe()) { + val topLevel = module.resolveTopLevelClass(fqName.toSafe()) + if (topLevel != null) return topLevel + } + + val parent = resolveClassByFqNameInModule(module, fqName.parent()) ?: return null + return parent.getUnsubstitutedInnerClassesScope().getClassifier(fqName.shortName()) as? ClassDescriptor + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java new file mode 100644 index 00000000000..08d337cb699 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java @@ -0,0 +1,3060 @@ +/* + * Copyright 2010-2015 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.runtime; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.InnerTestClasses; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/loadJava/compiledKotlin") +@TestDataPath("$PROJECT_ROOT") +@InnerTestClasses({ + JvmRuntimeDescriptorLoaderTestGenerated.Annotations.class, + JvmRuntimeDescriptorLoaderTestGenerated.Class.class, + JvmRuntimeDescriptorLoaderTestGenerated.ClassFun.class, + JvmRuntimeDescriptorLoaderTestGenerated.ClassObject.class, + JvmRuntimeDescriptorLoaderTestGenerated.Constructor.class, + JvmRuntimeDescriptorLoaderTestGenerated.DataClass.class, + JvmRuntimeDescriptorLoaderTestGenerated.Enum.class, + JvmRuntimeDescriptorLoaderTestGenerated.FromLoadJava.class, + JvmRuntimeDescriptorLoaderTestGenerated.Fun.class, + JvmRuntimeDescriptorLoaderTestGenerated.Inline.class, + JvmRuntimeDescriptorLoaderTestGenerated.MemberOrder.class, + JvmRuntimeDescriptorLoaderTestGenerated.Nested.class, + JvmRuntimeDescriptorLoaderTestGenerated.PlatformTypes.class, + JvmRuntimeDescriptorLoaderTestGenerated.Prop.class, + JvmRuntimeDescriptorLoaderTestGenerated.Type.class, + JvmRuntimeDescriptorLoaderTestGenerated.Visibility.class, +}) +@RunWith(JUnit3RunnerWithInners.class) +public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInCompiledKotlin() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + Annotations.ClassMembers.class, + Annotations.Classes.class, + Annotations.PackageMembers.class, + Annotations.Parameters.class, + Annotations.PropertiesWithoutBackingFields.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class Annotations extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInAnnotations() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("AnnotatedAnnotation.kt") + public void testAnnotatedAnnotation() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("AnnotatedMethod.kt") + public void testAnnotatedMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/AnnotatedMethod.kt"); + doTest(fileName); + } + + @TestMetadata("SimpleAnnotation.kt") + public void testSimpleAnnotation() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassMembers extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInClassMembers() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ClassObjectPropertyField.kt") + public void testClassObjectPropertyField() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.kt"); + doTest(fileName); + } + + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("EnumArgument.kt") + public void testEnumArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.kt"); + doTest(fileName); + } + + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.kt"); + doTest(fileName); + } + + @TestMetadata("Getter.kt") + public void testGetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyField.kt") + public void testPropertyField() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.kt"); + doTest(fileName); + } + + @TestMetadata("Setter.kt") + public void testSetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Classes extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInClasses() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("AnnotationInClassObject.kt") + public void testAnnotationInClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("ClassInClassObject.kt") + public void testClassInClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObject.kt") + public void testClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectInStaticNestedClass.kt") + public void testClassObjectInStaticNestedClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObjectInStaticNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Deprecated.kt"); + doTest(fileName); + } + + @TestMetadata("DollarsInAnnotationName.kt") + public void testDollarsInAnnotationName() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.kt"); + doTest(fileName); + } + + @TestMetadata("EnumArgument.kt") + public void testEnumArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.kt"); + doTest(fileName); + } + + @TestMetadata("MultipleAnnotations.kt") + public void testMultipleAnnotations() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("NestedAnnotation.kt") + public void testNestedAnnotation() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("NestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("Retention.kt") + public void testRetention() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.kt"); + doTest(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.kt"); + doTest(fileName); + } + + @TestMetadata("WithArgument.kt") + public void testWithArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.kt"); + doTest(fileName); + } + + @TestMetadata("WithMultipleArguments.kt") + public void testWithMultipleArguments() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PackageMembers extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInPackageMembers() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.kt"); + doTest(fileName); + } + + @TestMetadata("EnumArgument.kt") + public void testEnumArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.kt"); + doTest(fileName); + } + + @TestMetadata("EnumArrayArgument.kt") + public void testEnumArrayArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.kt"); + doTest(fileName); + } + + @TestMetadata("Function.kt") + public void testFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.kt"); + doTest(fileName); + } + + @TestMetadata("Getter.kt") + public void testGetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyField.kt") + public void testPropertyField() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.kt"); + doTest(fileName); + } + + @TestMetadata("Setter.kt") + public void testSetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.kt"); + doTest(fileName); + } + + @TestMetadata("StringArrayArgument.kt") + public void testStringArrayArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Parameters extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInParameters() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("Constructor.kt") + public void testConstructor() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.kt"); + doTest(fileName); + } + + @TestMetadata("EnumConstructor.kt") + public void testEnumConstructor() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionFunction.kt") + public void testExtensionFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionFunctionInClass.kt") + public void testExtensionFunctionInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionPropertySetter.kt") + public void testExtensionPropertySetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionInClass.kt") + public void testFunctionInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.kt"); + doTest(fileName); + } + + @TestMetadata("FunctionInTrait.kt") + public void testFunctionInTrait() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.kt"); + doTest(fileName); + } + + @TestMetadata("ManyAnnotations.kt") + public void testManyAnnotations() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.kt"); + doTest(fileName); + } + + @TestMetadata("PropertySetterInClass.kt") + public void testPropertySetterInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelFunction.kt") + public void testTopLevelFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelPropertySetter.kt") + public void testTopLevelPropertySetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PropertiesWithoutBackingFields extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("Class.kt") + public void testClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObject.kt") + public void testClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionsWithSameNameClass.kt") + public void testExtensionsWithSameNameClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtensionsWithSameNamePackage.kt") + public void testExtensionsWithSameNamePackage() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.kt"); + doTest(fileName); + } + + @TestMetadata("NestedTrait.kt") + public void testNestedTrait() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevel.kt") + public void testTopLevel() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.kt"); + doTest(fileName); + } + + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.kt"); + doTest(fileName); + } + + @TestMetadata("TraitClassObject.kt") + public void testTraitClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/class") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + Class.JavaBean.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class Class extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInClass() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("Class.kt") + public void testClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/Class.kt"); + doTest(fileName); + } + + @TestMetadata("ClassInParam.kt") + public void testClassInParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassInParam.kt"); + doTest(fileName); + } + + @TestMetadata("ClassInnerClass.kt") + public void testClassInnerClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("ClassMemberConflict.kt") + public void testClassMemberConflict() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassMemberConflict.kt"); + doTest(fileName); + } + + @TestMetadata("ClassOutParam.kt") + public void testClassOutParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassOutParam.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParam.kt") + public void testClassParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParam.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamReferencesParam.kt") + public void testClassParamReferencesParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamReferencesParam.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamReferencesParam2.kt") + public void testClassParamReferencesParam2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamReferencesParam2.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamReferencesSelf.kt") + public void testClassParamReferencesSelf() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamReferencesSelf.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamUpperClassBound.kt") + public void testClassParamUpperClassBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamUpperClassBound.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamUpperClassInterfaceBound.kt") + public void testClassParamUpperClassInterfaceBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamUpperClassInterfaceBound.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamUpperInterfaceBound.kt") + public void testClassParamUpperInterfaceBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassParamUpperInterfaceBound.kt"); + doTest(fileName); + } + + @TestMetadata("ClassTwoParams.kt") + public void testClassTwoParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassTwoParams.kt"); + doTest(fileName); + } + + @TestMetadata("ClassTwoParams2.kt") + public void testClassTwoParams2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/ClassTwoParams2.kt"); + doTest(fileName); + } + + @TestMetadata("EnumWithGenericConstructorParameter.kt") + public void testEnumWithGenericConstructorParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/EnumWithGenericConstructorParameter.kt"); + doTest(fileName); + } + + @TestMetadata("EnumWithPrimitiveConstructorParameter.kt") + public void testEnumWithPrimitiveConstructorParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/EnumWithPrimitiveConstructorParameter.kt"); + doTest(fileName); + } + + @TestMetadata("InheritClassSimple.kt") + public void testInheritClassSimple() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritClassSimple.kt"); + doTest(fileName); + } + + @TestMetadata("InheritClassWithParam.kt") + public void testInheritClassWithParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritClassWithParam.kt"); + doTest(fileName); + } + + @TestMetadata("InheritSubstitutedMethod.kt") + public void testInheritSubstitutedMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritSubstitutedMethod.kt"); + doTest(fileName); + } + + @TestMetadata("InheritTraitWithFunctionParam.kt") + public void testInheritTraitWithFunctionParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritTraitWithFunctionParam.kt"); + doTest(fileName); + } + + @TestMetadata("InheritTraitWithParam.kt") + public void testInheritTraitWithParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InheritTraitWithParam.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassExtendInnerClass.kt") + public void testInnerClassExtendInnerClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InnerClassExtendInnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("InnerGenericClass.kt") + public void testInnerGenericClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/InnerGenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("NamedObject.kt") + public void testNamedObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObject.kt"); + doTest(fileName); + } + + @TestMetadata("NamedObjectInClass.kt") + public void testNamedObjectInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectInClass.kt"); + doTest(fileName); + } + + @TestMetadata("NamedObjectInClassObject.kt") + public void testNamedObjectInClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("NamedObjectInNamedObject.kt") + public void testNamedObjectInNamedObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectInNamedObject.kt"); + doTest(fileName); + } + + @TestMetadata("NamedObjectWithAnotherTopLevelProperty.kt") + public void testNamedObjectWithAnotherTopLevelProperty() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NamedObjectWithAnotherTopLevelProperty.kt"); + doTest(fileName); + } + + @TestMetadata("NestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("NestedClassExtendNestedClass.kt") + public void testNestedClassExtendNestedClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NestedClassExtendNestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("NestedGenericClass.kt") + public void testNestedGenericClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/NestedGenericClass.kt"); + doTest(fileName); + } + + @TestMetadata("SingleAbstractMethod.kt") + public void testSingleAbstractMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/SingleAbstractMethod.kt"); + doTest(fileName); + } + + @TestMetadata("Trait.kt") + public void testTrait() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/Trait.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JavaBean extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInJavaBean() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("DifferentGetterAndSetter.kt") + public void testDifferentGetterAndSetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/DifferentGetterAndSetter.kt"); + doTest(fileName); + } + + @TestMetadata("JavaBeanAbstractGetter.kt") + public void testJavaBeanAbstractGetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanAbstractGetter.kt"); + doTest(fileName); + } + + @TestMetadata("JavaBeanVal.kt") + public void testJavaBeanVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanVal.kt"); + doTest(fileName); + } + + @TestMetadata("JavaBeanVar.kt") + public void testJavaBeanVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanVar.kt"); + doTest(fileName); + } + + @TestMetadata("JavaBeanVarOfGenericType.kt") + public void testJavaBeanVarOfGenericType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/JavaBeanVarOfGenericType.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSetters.kt") + public void testTwoSetters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/class/javaBean/TwoSetters.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/classFun") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassFun extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInClassFun() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ClassInParamUsedInFun.kt") + public void testClassInParamUsedInFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/ClassInParamUsedInFun.kt"); + doTest(fileName); + } + + @TestMetadata("ClassParamUsedInFun.kt") + public void testClassParamUsedInFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/ClassParamUsedInFun.kt"); + doTest(fileName); + } + + @TestMetadata("FunDelegationToTraitImpl.kt") + public void testFunDelegationToTraitImpl() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/FunDelegationToTraitImpl.kt"); + doTest(fileName); + } + + @TestMetadata("FunInParamSuper.kt") + public void testFunInParamSuper() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/FunInParamSuper.kt"); + doTest(fileName); + } + + @TestMetadata("TraitFinalFun.kt") + public void testTraitFinalFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/TraitFinalFun.kt"); + doTest(fileName); + } + + @TestMetadata("TraitOpenFun.kt") + public void testTraitOpenFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classFun/TraitOpenFun.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/classObject") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ClassObject extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInClassObject() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ClassObjectDeclaresVal.kt") + public void testClassObjectDeclaresVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectDeclaresVal.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectDeclaresVar.kt") + public void testClassObjectDeclaresVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectDeclaresVar.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectDefaultVisibility.kt") + public void testClassObjectDefaultVisibility() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectDefaultVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectExplicitVisibility.kt") + public void testClassObjectExplicitVisibility() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectExplicitVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectExtendsTrait.kt") + public void testClassObjectExtendsTrait() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectExtendsTrait.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectExtendsTraitWithTP.kt") + public void testClassObjectExtendsTraitWithTP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectExtendsTraitWithTP.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectInClassStaticFields.kt") + public void testClassObjectInClassStaticFields() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/classObjectInClassStaticFields.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectInTraitStaticFields.kt") + public void testClassObjectInTraitStaticFields() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/classObjectInTraitStaticFields.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObjectPropertyInClass.kt") + public void testClassObjectPropertyInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/ClassObjectPropertyInClass.kt"); + doTest(fileName); + } + + @TestMetadata("Delegation.kt") + public void testDelegation() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/Delegation.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassInClassObject.kt") + public void testInnerClassInClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/InnerClassInClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("NamedClassObject.kt") + public void testNamedClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/NamedClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("SimpleClassObject.kt") + public void testSimpleClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/classObject/SimpleClassObject.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/constructor") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + Constructor.Vararg.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class Constructor extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInConstructor() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("Constructor0.kt") + public void testConstructor0() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor0.kt"); + doTest(fileName); + } + + @TestMetadata("Constructor1.kt") + public void testConstructor1() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor1.kt"); + doTest(fileName); + } + + @TestMetadata("Constructor1WithParamDefaultValue.kt") + public void testConstructor1WithParamDefaultValue() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor1WithParamDefaultValue.kt"); + doTest(fileName); + } + + @TestMetadata("Constructor2WithOneParamDefaultValue.kt") + public void testConstructor2WithOneParamDefaultValue() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/Constructor2WithOneParamDefaultValue.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorCollectionParameter.kt") + public void testConstructorCollectionParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorCollectionParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorGenericDeep.kt") + public void testConstructorGenericDeep() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorGenericDeep.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorGenericSimple.kt") + public void testConstructorGenericSimple() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorGenericSimple.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorGenericUpperBound.kt") + public void testConstructorGenericUpperBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorGenericUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithTwoDefArgs.kt") + public void testConstructorWithTwoDefArgs() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoDefArgs.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithTwoTypeParameters.kt") + public void testConstructorWithTwoTypeParameters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithTwoTypeParametersAndOneIntValueParameter.kt") + public void testConstructorWithTwoTypeParametersAndOneIntValueParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoTypeParametersAndOneIntValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithTwoTypeParametersAndOnePValueParameter.kt") + public void testConstructorWithTwoTypeParametersAndOnePValueParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTwoTypeParametersAndOnePValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithTypeParameter.kt") + public void testConstructorWithTypeParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithTypeParametersEAndOnePValueParameter.kt") + public void testConstructorWithTypeParametersEAndOnePValueParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/ConstructorWithTypeParametersEAndOnePValueParameter.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClassConstructorWithDefArgs.kt") + public void testInnerClassConstructorWithDefArgs() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/InnerClassConstructorWithDefArgs.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateConstructor1WithParamDefaultValue.kt") + public void testPrivateConstructor1WithParamDefaultValue() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/PrivateConstructor1WithParamDefaultValue.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInVararg() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ConstructorNonLastVararg.kt") + public void testConstructorNonLastVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg/ConstructorNonLastVararg.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorVararg.kt") + public void testConstructorVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/constructor/vararg/ConstructorVararg.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/dataClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DataClass extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInDataClass() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("MixedComponents.kt") + public void testMixedComponents() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/MixedComponents.kt"); + doTest(fileName); + } + + @TestMetadata("NoComponents.kt") + public void testNoComponents() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/NoComponents.kt"); + doTest(fileName); + } + + @TestMetadata("OneVal.kt") + public void testOneVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/OneVal.kt"); + doTest(fileName); + } + + @TestMetadata("OpenDataClass.kt") + public void testOpenDataClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/OpenDataClass.kt"); + doTest(fileName); + } + + @TestMetadata("OpenPropertyFinalComponent.kt") + public void testOpenPropertyFinalComponent() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/OpenPropertyFinalComponent.kt"); + doTest(fileName); + } + + @TestMetadata("ParamNameSameToField.kt") + public void testParamNameSameToField() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/ParamNameSameToField.kt"); + doTest(fileName); + } + + @TestMetadata("TwoVals.kt") + public void testTwoVals() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/TwoVals.kt"); + doTest(fileName); + } + + @TestMetadata("TwoVars.kt") + public void testTwoVars() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/dataClass/TwoVars.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInEnum() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("enumVisibility.kt") + public void testEnumVisibility() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/enumVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("enumWithConstuctor.kt") + public void testEnumWithConstuctor() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/enumWithConstuctor.kt"); + doTest(fileName); + } + + @TestMetadata("enumWithInnerClasses.kt") + public void testEnumWithInnerClasses() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/enumWithInnerClasses.kt"); + doTest(fileName); + } + + @TestMetadata("innerEnum.kt") + public void testInnerEnum() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/innerEnum.kt"); + doTest(fileName); + } + + @TestMetadata("innerEnumExistingClassObject.kt") + public void testInnerEnumExistingClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/innerEnumExistingClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/enum/simpleEnum.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + FromLoadJava.KotlinSignature.class, + FromLoadJava.Library.class, + FromLoadJava.Modality.class, + FromLoadJava.NotNull.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class FromLoadJava extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInFromLoadJava() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ArrayTypeVariance.kt") + public void testArrayTypeVariance() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ArrayTypeVariance.kt"); + doTest(fileName); + } + + @TestMetadata("ClassDoesNotOverrideMethod.kt") + public void testClassDoesNotOverrideMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassDoesNotOverrideMethod.kt"); + doTest(fileName); + } + + @TestMetadata("ClassObject.kt") + public void testClassObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassObject.kt"); + doTest(fileName); + } + + @TestMetadata("classObjectAnnotation.kt") + public void testClassObjectAnnotation() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithConstVal.kt") + public void testClassWithConstVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithConstVal.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithTypeP.kt") + public void testClassWithTypeP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypeP.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithTypePExtendsIterableP.kt") + public void testClassWithTypePExtendsIterableP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePExtendsIterableP.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithTypePP.kt") + public void testClassWithTypePP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePP.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithTypePRefNext.kt") + public void testClassWithTypePRefNext() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePRefNext.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithTypePRefSelf.kt") + public void testClassWithTypePRefSelf() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePRefSelf.kt"); + doTest(fileName); + } + + @TestMetadata("ClassWithTypePRefSelfAndClass.kt") + public void testClassWithTypePRefSelfAndClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/ClassWithTypePRefSelfAndClass.kt"); + doTest(fileName); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/enum.kt"); + doTest(fileName); + } + + @TestMetadata("FieldAsVar.kt") + public void testFieldAsVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/FieldAsVar.kt"); + doTest(fileName); + } + + @TestMetadata("FieldOfArrayType.kt") + public void testFieldOfArrayType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/FieldOfArrayType.kt"); + doTest(fileName); + } + + @TestMetadata("FinalFieldAsVal.kt") + public void testFinalFieldAsVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/FinalFieldAsVal.kt"); + doTest(fileName); + } + + @TestMetadata("genericFunction.kt") + public void testGenericFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/genericFunction.kt"); + doTest(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypes.kt") + public void testInheritMethodsDifferentReturnTypes() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/InheritMethodsDifferentReturnTypes.kt"); + doTest(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypesGeneric.kt") + public void testInheritMethodsDifferentReturnTypesGeneric() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/InheritMethodsDifferentReturnTypesGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("InnerClass.kt") + public void testInnerClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/InnerClass.kt"); + doTest(fileName); + } + + @TestMetadata("MethodTypePOneUpperBound.kt") + public void testMethodTypePOneUpperBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodTypePOneUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("MethodTypePTwoUpperBounds.kt") + public void testMethodTypePTwoUpperBounds() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodTypePTwoUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithTypeP.kt") + public void testMethodWithTypeP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodWithTypeP.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithTypePP.kt") + public void testMethodWithTypePP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodWithTypePP.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithTypePRefClassP.kt") + public void testMethodWithTypePRefClassP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethodWithTypePRefClassP.kt"); + doTest(fileName); + } + + @TestMetadata("MethosWithPRefTP.kt") + public void testMethosWithPRefTP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MethosWithPRefTP.kt"); + doTest(fileName); + } + + @TestMetadata("MyException.kt") + public void testMyException() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/MyException.kt"); + doTest(fileName); + } + + @TestMetadata("NestedClass.kt") + public void testNestedClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/NestedClass.kt"); + doTest(fileName); + } + + @TestMetadata("objectInClass.kt") + public void testObjectInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/objectInClass.kt"); + doTest(fileName); + } + + @TestMetadata("objectMembers.kt") + public void testObjectMembers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/objectMembers.kt"); + doTest(fileName); + } + + @TestMetadata("packageLevelObject.kt") + public void testPackageLevelObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/packageLevelObject.kt"); + doTest(fileName); + } + + @TestMetadata("RemoveRedundantProjectionKind.kt") + public void testRemoveRedundantProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/RemoveRedundantProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("Simple.kt") + public void testSimple() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/Simple.kt"); + doTest(fileName); + } + + @TestMetadata("TwoFields.kt") + public void testTwoFields() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/TwoFields.kt"); + doTest(fileName); + } + + @TestMetadata("UnboundWildcard.kt") + public void testUnboundWildcard() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/UnboundWildcard.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + KotlinSignature.Error.class, + KotlinSignature.Propagation.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class KotlinSignature extends AbstractJvmRuntimeDescriptorLoaderTest { + @TestMetadata("AllBoundsInWhen.kt") + public void testAllBoundsInWhen() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/AllBoundsInWhen.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInKotlinSignature() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ArrayType.kt") + public void testArrayType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ArrayType.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithNewTypeParams.kt") + public void testConstructorWithNewTypeParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithNewTypeParams.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithParentTypeParams.kt") + public void testConstructorWithParentTypeParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithParentTypeParams.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithSeveralParams.kt") + public void testConstructorWithSeveralParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithSeveralParams.kt"); + doTest(fileName); + } + + @TestMetadata("ConstructorWithoutParams.kt") + public void testConstructorWithoutParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/ConstructorWithoutParams.kt"); + doTest(fileName); + } + + @TestMetadata("CustomProjectionKind.kt") + public void testCustomProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/CustomProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithFunctionTypes.kt") + public void testMethodWithFunctionTypes() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithFunctionTypes.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithGenerics.kt") + public void testMethodWithGenerics() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithGenerics.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithMappedClasses.kt") + public void testMethodWithMappedClasses() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithMappedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithTypeParameters.kt") + public void testMethodWithTypeParameters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("MethodWithVararg.kt") + public void testMethodWithVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/MethodWithVararg.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyArrayTypes.kt") + public void testPropertyArrayTypes() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/PropertyArrayTypes.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyComplexTypes.kt") + public void testPropertyComplexTypes() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/PropertyComplexTypes.kt"); + doTest(fileName); + } + + @TestMetadata("PropertySimpleType.kt") + public void testPropertySimpleType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/PropertySimpleType.kt"); + doTest(fileName); + } + + @TestMetadata("StarProjection.kt") + public void testStarProjection() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/StarProjection.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Error extends AbstractJvmRuntimeDescriptorLoaderTest { + @TestMetadata("AddingNullability.kt") + public void testAddingNullability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/AddingNullability.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInError() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ConflictingProjectionKind.kt") + public void testConflictingProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ConflictingProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("ExplicitFieldGettersAndSetters.kt") + public void testExplicitFieldGettersAndSetters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ExplicitFieldGettersAndSetters.kt"); + doTest(fileName); + } + + @TestMetadata("ExtraUpperBound.kt") + public void testExtraUpperBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ExtraUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("MissingUpperBound.kt") + public void testMissingUpperBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/MissingUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("NoFieldTypeRef.kt") + public void testNoFieldTypeRef() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/NoFieldTypeRef.kt"); + doTest(fileName); + } + + @TestMetadata("NotVarargReplacedWithVararg.kt") + public void testNotVarargReplacedWithVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/NotVarargReplacedWithVararg.kt"); + doTest(fileName); + } + + @TestMetadata("RedundantProjectionKind.kt") + public void testRedundantProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/RedundantProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeMissing.kt") + public void testReturnTypeMissing() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/ReturnTypeMissing.kt"); + doTest(fileName); + } + + @TestMetadata("SyntaxError.kt") + public void testSyntaxError() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/SyntaxError.kt"); + doTest(fileName); + } + + @TestMetadata("SyntaxErrorInFieldAnnotation.kt") + public void testSyntaxErrorInFieldAnnotation() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/SyntaxErrorInFieldAnnotation.kt"); + doTest(fileName); + } + + @TestMetadata("VarargReplacedWithNotVararg.kt") + public void testVarargReplacedWithNotVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/VarargReplacedWithNotVararg.kt"); + doTest(fileName); + } + + @TestMetadata("WrongFieldInitializer.kt") + public void testWrongFieldInitializer() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongFieldInitializer.kt"); + doTest(fileName); + } + + @TestMetadata("WrongFieldMutability.kt") + public void testWrongFieldMutability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongFieldMutability.kt"); + doTest(fileName); + } + + @TestMetadata("WrongFieldName.kt") + public void testWrongFieldName() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongFieldName.kt"); + doTest(fileName); + } + + @TestMetadata("WrongMethodName.kt") + public void testWrongMethodName() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongMethodName.kt"); + doTest(fileName); + } + + @TestMetadata("WrongProjectionKind.kt") + public void testWrongProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("WrongReturnTypeStructure.kt") + public void testWrongReturnTypeStructure() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongReturnTypeStructure.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTypeName1.kt") + public void testWrongTypeName1() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeName1.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTypeName2.kt") + public void testWrongTypeName2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeName2.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTypeName3.kt") + public void testWrongTypeName3() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeName3.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTypeParameterBoundStructure1.kt") + public void testWrongTypeParameterBoundStructure1() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeParameterBoundStructure1.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTypeParameterBoundStructure2.kt") + public void testWrongTypeParameterBoundStructure2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeParameterBoundStructure2.kt"); + doTest(fileName); + } + + @TestMetadata("WrongTypeParametersCount.kt") + public void testWrongTypeParametersCount() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongTypeParametersCount.kt"); + doTest(fileName); + } + + @TestMetadata("WrongValueParameterStructure1.kt") + public void testWrongValueParameterStructure1() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongValueParameterStructure1.kt"); + doTest(fileName); + } + + @TestMetadata("WrongValueParameterStructure2.kt") + public void testWrongValueParameterStructure2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongValueParameterStructure2.kt"); + doTest(fileName); + } + + @TestMetadata("WrongValueParametersCount.kt") + public void testWrongValueParametersCount() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error/WrongValueParametersCount.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + Propagation.Parameter.class, + Propagation.Return.class, + Propagation.TypeParameter.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class Propagation extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInPropagation() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("PropagateTypeArgumentNullable.kt") + public void testPropagateTypeArgumentNullable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/PropagateTypeArgumentNullable.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Parameter extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInParameter() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ChangeProjectionKind1.kt") + public void testChangeProjectionKind1() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind1.kt"); + doTest(fileName); + } + + @TestMetadata("ChangeProjectionKind2.kt") + public void testChangeProjectionKind2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ChangeProjectionKind2.kt"); + doTest(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter.kt") + public void testDeeplySubstitutedClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter.kt"); + doTest(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.kt") + public void testDeeplySubstitutedClassParameter2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/DeeplySubstitutedClassParameter2.kt"); + doTest(fileName); + } + + @TestMetadata("InheritMutability.kt") + public void testInheritMutability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritMutability.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNotVararg.kt") + public void testInheritNotVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVararg.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNotVarargInteger.kt") + public void testInheritNotVarargInteger() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargInteger.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNotVarargNotNull.kt") + public void testInheritNotVarargNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNotVarargPrimitive.kt") + public void testInheritNotVarargPrimitive() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNotVarargPrimitive.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNullability.kt") + public void testInheritNullability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritNullability.kt"); + doTest(fileName); + } + + @TestMetadata("InheritProjectionKind.kt") + public void testInheritProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("InheritReadOnliness.kt") + public void testInheritReadOnliness() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritReadOnliness.kt"); + doTest(fileName); + } + + @TestMetadata("InheritVararg.kt") + public void testInheritVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVararg.kt"); + doTest(fileName); + } + + @TestMetadata("InheritVarargInteger.kt") + public void testInheritVarargInteger() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargInteger.kt"); + doTest(fileName); + } + + @TestMetadata("InheritVarargNotNull.kt") + public void testInheritVarargNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("InheritVarargPrimitive.kt") + public void testInheritVarargPrimitive() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/InheritVarargPrimitive.kt"); + doTest(fileName); + } + + @TestMetadata("Kt3302.kt") + public void testKt3302() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/Kt3302.kt"); + doTest(fileName); + } + + @TestMetadata("MutableToReadOnly.kt") + public void testMutableToReadOnly() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/MutableToReadOnly.kt"); + doTest(fileName); + } + + @TestMetadata("NotNullToNullable.kt") + public void testNotNullToNullable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NotNullToNullable.kt"); + doTest(fileName); + } + + @TestMetadata("NullableToNotNull.kt") + public void testNullableToNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("NullableToNotNullKotlinSignature.kt") + public void testNullableToNotNullKotlinSignature() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/NullableToNotNullKotlinSignature.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideWithErasedParameter.kt") + public void testOverrideWithErasedParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/OverrideWithErasedParameter.kt"); + doTest(fileName); + } + + @TestMetadata("ReadOnlyToMutable.kt") + public void testReadOnlyToMutable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/ReadOnlyToMutable.kt"); + doTest(fileName); + } + + @TestMetadata("SubclassFromGenericAndNot.kt") + public void testSubclassFromGenericAndNot() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubclassFromGenericAndNot.kt"); + doTest(fileName); + } + + @TestMetadata("SubstitutedClassParameter.kt") + public void testSubstitutedClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameter.kt"); + doTest(fileName); + } + + @TestMetadata("SubstitutedClassParameters.kt") + public void testSubstitutedClassParameters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter/SubstitutedClassParameters.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Return extends AbstractJvmRuntimeDescriptorLoaderTest { + @TestMetadata("AddNotNullJavaSubtype.kt") + public void testAddNotNullJavaSubtype() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("AddNotNullSameJavaType.kt") + public void testAddNotNullSameJavaType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt"); + doTest(fileName); + } + + @TestMetadata("AddNullabilityJavaSubtype.kt") + public void testAddNullabilityJavaSubtype() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("AddNullabilitySameGenericType1.kt") + public void testAddNullabilitySameGenericType1() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType1.kt"); + doTest(fileName); + } + + @TestMetadata("AddNullabilitySameGenericType2.kt") + public void testAddNullabilitySameGenericType2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameGenericType2.kt"); + doTest(fileName); + } + + @TestMetadata("AddNullabilitySameJavaType.kt") + public void testAddNullabilitySameJavaType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt"); + doTest(fileName); + } + + public void testAllFilesPresentInReturn() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("CantMakeImmutableInSubclass.kt") + public void testCantMakeImmutableInSubclass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/CantMakeImmutableInSubclass.kt"); + doTest(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter.kt") + public void testDeeplySubstitutedClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter.kt"); + doTest(fileName); + } + + @TestMetadata("DeeplySubstitutedClassParameter2.kt") + public void testDeeplySubstitutedClassParameter2() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/DeeplySubstitutedClassParameter2.kt"); + doTest(fileName); + } + + @TestMetadata("HalfSubstitutedTypeParameters.kt") + public void testHalfSubstitutedTypeParameters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/HalfSubstitutedTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNullabilityGenericSubclassSimple.kt") + public void testInheritNullabilityGenericSubclassSimple() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityGenericSubclassSimple.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNullabilityJavaSubtype.kt") + public void testInheritNullabilityJavaSubtype() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNullabilitySameGenericType.kt") + public void testInheritNullabilitySameGenericType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameGenericType.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNullabilitySameJavaType.kt") + public void testInheritNullabilitySameJavaType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt"); + doTest(fileName); + } + + @TestMetadata("InheritProjectionKind.kt") + public void testInheritProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("InheritReadOnlinessOfArgument.kt") + public void testInheritReadOnlinessOfArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessOfArgument.kt"); + doTest(fileName); + } + + @TestMetadata("InheritReadOnlinessSameClass.kt") + public void testInheritReadOnlinessSameClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSameClass.kt"); + doTest(fileName); + } + + @TestMetadata("InheritReadOnlinessSubclass.kt") + public void testInheritReadOnlinessSubclass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/InheritReadOnlinessSubclass.kt"); + doTest(fileName); + } + + @TestMetadata("SameProjectionKind.kt") + public void testSameProjectionKind() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SameProjectionKind.kt"); + doTest(fileName); + } + + @TestMetadata("SubclassFromGenericAndNot.kt") + public void testSubclassFromGenericAndNot() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassFromGenericAndNot.kt"); + doTest(fileName); + } + + @TestMetadata("SubclassOfCollection.kt") + public void testSubclassOfCollection() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfCollection.kt"); + doTest(fileName); + } + + @TestMetadata("SubclassOfMapEntry.kt") + public void testSubclassOfMapEntry() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubclassOfMapEntry.kt"); + doTest(fileName); + } + + @TestMetadata("SubstitutedClassParameter.kt") + public void testSubstitutedClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubstitutedClassParameter.kt"); + doTest(fileName); + } + + @TestMetadata("SubstitutedClassParameters.kt") + public void testSubstitutedClassParameters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/SubstitutedClassParameters.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesConflictingProjectionKinds.kt") + public void testTwoSuperclassesConflictingProjectionKinds() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesConflictingProjectionKinds.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferMutability.kt") + public void testTwoSuperclassesInvariantAndCovariantInferMutability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferMutability.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesInvariantAndCovariantInferNullability.kt") + public void testTwoSuperclassesInvariantAndCovariantInferNullability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesInvariantAndCovariantInferNullability.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesMutableAndNot.kt") + public void testTwoSuperclassesMutableAndNot() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesMutableAndNot.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesReturnJavaSubtype.kt") + public void testTwoSuperclassesReturnJavaSubtype() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnJavaSubtype.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesReturnSameJavaType.kt") + public void testTwoSuperclassesReturnSameJavaType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesReturnSameJavaType.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclassesSupplementNotNull.kt") + public void testTwoSuperclassesSupplementNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TwoSuperclassesSupplementNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParamOfClass.kt") + public void testTypeParamOfClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TypeParamOfClass.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParamOfClassSubstituted.kt") + public void testTypeParamOfClassSubstituted() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.kt"); + doTest(fileName); + } + + @TestMetadata("TypeParamOfFun.kt") + public void testTypeParamOfFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return/TypeParamOfFun.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameter extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInTypeParameter() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("InheritMutability.kt") + public void testInheritMutability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/InheritMutability.kt"); + doTest(fileName); + } + + @TestMetadata("InheritNullability.kt") + public void testInheritNullability() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/InheritNullability.kt"); + doTest(fileName); + } + + @TestMetadata("InheritReadOnliness.kt") + public void testInheritReadOnliness() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/InheritReadOnliness.kt"); + doTest(fileName); + } + + @TestMetadata("TwoBounds.kt") + public void testTwoBounds() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/TwoBounds.kt"); + doTest(fileName); + } + + @TestMetadata("TwoSuperclasses.kt") + public void testTwoSuperclasses() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/TwoSuperclasses.kt"); + doTest(fileName); + } + + @TestMetadata("TwoTypeParameters.kt") + public void testTwoTypeParameters() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/TwoTypeParameters.kt"); + doTest(fileName); + } + + @TestMetadata("UseParameterAsUpperBound.kt") + public void testUseParameterAsUpperBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/UseParameterAsUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("UseParameterInUpperBound.kt") + public void testUseParameterInUpperBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBound.kt"); + doTest(fileName); + } + + @TestMetadata("UseParameterInUpperBoundWithKotlinSignature.kt") + public void testUseParameterInUpperBoundWithKotlinSignature() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter/UseParameterInUpperBoundWithKotlinSignature.kt"); + doTest(fileName); + } + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Library extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInLibrary() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("LoadIterable.kt") + public void testLoadIterable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library/LoadIterable.kt"); + doTest(fileName); + } + + @TestMetadata("LoadIterator.kt") + public void testLoadIterator() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library/LoadIterator.kt"); + doTest(fileName); + } + + @TestMetadata("Max.kt") + public void testMax() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library/Max.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Modality extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInModality() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ModalityOfFakeOverrides.kt") + public void testModalityOfFakeOverrides() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality/ModalityOfFakeOverrides.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NotNull extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInNotNull() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("NotNullField.kt") + public void testNotNullField() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullField.kt"); + doTest(fileName); + } + + @TestMetadata("NotNullIntArray.kt") + public void testNotNullIntArray() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullIntArray.kt"); + doTest(fileName); + } + + @TestMetadata("NotNullMethod.kt") + public void testNotNullMethod() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullMethod.kt"); + doTest(fileName); + } + + @TestMetadata("NotNullObjectArray.kt") + public void testNotNullObjectArray() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullObjectArray.kt"); + doTest(fileName); + } + + @TestMetadata("NotNullParameter.kt") + public void testNotNullParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull/NotNullParameter.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + Fun.GenericWithTypeVariables.class, + Fun.GenericWithoutTypeVariables.class, + Fun.NonGeneric.class, + Fun.Vararg.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class Fun extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInFun() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("Assert.kt") + public void testAssert() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/Assert.kt"); + doTest(fileName); + } + + @TestMetadata("DeclaredMemberOverridesDelegated.kt") + public void testDeclaredMemberOverridesDelegated() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/DeclaredMemberOverridesDelegated.kt"); + doTest(fileName); + } + + @TestMetadata("InheritMethodsDifferentReturnTypesAndVisibilities.kt") + public void testInheritMethodsDifferentReturnTypesAndVisibilities() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InheritMethodsDifferentReturnTypesAndVisibilities.kt"); + doTest(fileName); + } + + @TestMetadata("InheritValAndVar.kt") + public void testInheritValAndVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InheritValAndVar.kt"); + doTest(fileName); + } + + @TestMetadata("InheritValsDifferentTypes.kt") + public void testInheritValsDifferentTypes() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/InheritValsDifferentTypes.kt"); + doTest(fileName); + } + + @TestMetadata("NoDelegationForFunctionInheritedFromTraitSuperClass.kt") + public void testNoDelegationForFunctionInheritedFromTraitSuperClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/NoDelegationForFunctionInheritedFromTraitSuperClass.kt"); + doTest(fileName); + } + + @TestMetadata("NoSamAdapter.kt") + public void testNoSamAdapter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/NoSamAdapter.kt"); + doTest(fileName); + } + + @TestMetadata("NoSamConstructor.kt") + public void testNoSamConstructor() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/NoSamConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("PropagateDeepSubclass.kt") + public void testPropagateDeepSubclass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/PropagateDeepSubclass.kt"); + doTest(fileName); + } + + @TestMetadata("PropagateSubclassOfComparable.kt") + public void testPropagateSubclassOfComparable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/PropagateSubclassOfComparable.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class GenericWithTypeVariables extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("FunGenericParam.kt") + public void testFunGenericParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunGenericParam.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamParam.kt") + public void testFunParamParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamParam.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamParamErased.kt") + public void testFunParamParamErased() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamParamErased.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamReferencesParam.kt") + public void testFunParamReferencesParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamReferencesParam.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamTwoUpperBounds.kt") + public void testFunParamTwoUpperBounds() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamTwoUpperBounds.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamUpperClassBound.kt") + public void testFunParamUpperClassBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamUpperClassBound.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamUpperClassInterfaceBound.kt") + public void testFunParamUpperClassInterfaceBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamUpperClassInterfaceBound.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamUpperInterfaceBound.kt") + public void testFunParamUpperInterfaceBound() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamUpperInterfaceBound.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamVaragParam.kt") + public void testFunParamVaragParam() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunParamVaragParam.kt"); + doTest(fileName); + } + + @TestMetadata("FunTwoTypeParams.kt") + public void testFunTwoTypeParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables/FunTwoTypeParams.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class GenericWithoutTypeVariables extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("FunClassParamNotNull.kt") + public void testFunClassParamNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/FunClassParamNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("FunClassParamNullable.kt") + public void testFunClassParamNullable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/FunClassParamNullable.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamNullable.kt") + public void testFunParamNullable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/FunParamNullable.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeClassParamNotNull.kt") + public void testReturnTypeClassParamNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/ReturnTypeClassParamNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeClassParamNullable.kt") + public void testReturnTypeClassParamNullable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables/ReturnTypeClassParamNullable.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonGeneric extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInNonGeneric() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ClassFun.kt") + public void testClassFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFun.kt"); + doTest(fileName); + } + + @TestMetadata("ClassFunGetFoo.kt") + public void testClassFunGetFoo() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFunGetFoo.kt"); + doTest(fileName); + } + + @TestMetadata("ClassFunGetFooSetFoo.kt") + public void testClassFunGetFooSetFoo() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFunGetFooSetFoo.kt"); + doTest(fileName); + } + + @TestMetadata("ClassFunSetFoo.kt") + public void testClassFunSetFoo() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ClassFunSetFoo.kt"); + doTest(fileName); + } + + @TestMetadata("ExtFun.kt") + public void testExtFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ExtFun.kt"); + doTest(fileName); + } + + @TestMetadata("ExtFunInClass.kt") + public void testExtFunInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ExtFunInClass.kt"); + doTest(fileName); + } + + @TestMetadata("FunDefaultArg.kt") + public void testFunDefaultArg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunDefaultArg.kt"); + doTest(fileName); + } + + @TestMetadata("FunParamNotNull.kt") + public void testFunParamNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunParamNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("FunVarargInt.kt") + public void testFunVarargInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunVarargInt.kt"); + doTest(fileName); + } + + @TestMetadata("FunVarargInteger.kt") + public void testFunVarargInteger() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/FunVarargInteger.kt"); + doTest(fileName); + } + + @TestMetadata("ModifierAbstract.kt") + public void testModifierAbstract() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ModifierAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("ModifierOpen.kt") + public void testModifierOpen() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ModifierOpen.kt"); + doTest(fileName); + } + + @TestMetadata("NsFun.kt") + public void testNsFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/NsFun.kt"); + doTest(fileName); + } + + @TestMetadata("NsFunGetFoo.kt") + public void testNsFunGetFoo() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/NsFunGetFoo.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeNotNull.kt") + public void testReturnTypeNotNull() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ReturnTypeNotNull.kt"); + doTest(fileName); + } + + @TestMetadata("ReturnTypeNullable.kt") + public void testReturnTypeNullable() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric/ReturnTypeNullable.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Vararg extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInVararg() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("nonLastVararg.kt") + public void testNonLastVararg() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg/nonLastVararg.kt"); + doTest(fileName); + } + + @TestMetadata("VarargInt.kt") + public void testVarargInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg/VarargInt.kt"); + doTest(fileName); + } + + @TestMetadata("VarargString.kt") + public void testVarargString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/fun/vararg/VarargString.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/inline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Inline extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInInline() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("inlineFunction.kt") + public void testInlineFunction() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/inline/inlineFunction.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MemberOrder extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInMemberOrder() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("callablesNameClash.kt") + public void testCallablesNameClash() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/callablesNameClash.kt"); + doTest(fileName); + } + + @TestMetadata("enumEntries.kt") + public void testEnumEntries() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/enumEntries.kt"); + doTest(fileName); + } + + @TestMetadata("extensionMembers.kt") + public void testExtensionMembers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/extensionMembers.kt"); + doTest(fileName); + } + + @TestMetadata("extensionPropertiesNameClash.kt") + public void testExtensionPropertiesNameClash() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/extensionPropertiesNameClash.kt"); + doTest(fileName); + } + + @TestMetadata("innerClasses.kt") + public void testInnerClasses() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/innerClasses.kt"); + doTest(fileName); + } + + @TestMetadata("topLevelCallables.kt") + public void testTopLevelCallables() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/memberOrder/topLevelCallables.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/nested") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Nested extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInNested() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("deepInnerGeneric.kt") + public void testDeepInnerGeneric() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/nested/deepInnerGeneric.kt"); + doTest(fileName); + } + + @TestMetadata("innerClassReferencesOuterTP.kt") + public void testInnerClassReferencesOuterTP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/nested/innerClassReferencesOuterTP.kt"); + doTest(fileName); + } + + @TestMetadata("membersReferenceOuterTP.kt") + public void testMembersReferenceOuterTP() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/nested/membersReferenceOuterTP.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PlatformTypes extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInPlatformTypes() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("notnullTypeArgument.kt") + public void testNotnullTypeArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes/notnullTypeArgument.kt"); + doTest(fileName); + } + + @TestMetadata("nullableTypeArgument.kt") + public void testNullableTypeArgument() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/platformTypes/nullableTypeArgument.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/prop") + @TestDataPath("$PROJECT_ROOT") + @InnerTestClasses({ + Prop.DefaultAccessors.class, + }) + @RunWith(JUnit3RunnerWithInners.class) + public static class Prop extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInProp() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ClassVal.kt") + public void testClassVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ClassVal.kt"); + doTest(fileName); + } + + @TestMetadata("ClassValAbstract.kt") + public void testClassValAbstract() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ClassValAbstract.kt"); + doTest(fileName); + } + + @TestMetadata("ClassVar.kt") + public void testClassVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ClassVar.kt"); + doTest(fileName); + } + + @TestMetadata("CollectionSize.kt") + public void testCollectionSize() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/CollectionSize.kt"); + doTest(fileName); + } + + @TestMetadata("Constants.kt") + public void testConstants() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/Constants.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValClass.kt") + public void testExtValClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValInClass.kt") + public void testExtValInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValInt.kt") + public void testExtValInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValInt.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValIntCharSequence.kt") + public void testExtValIntCharSequence() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntCharSequence.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValIntCharSequenceQ.kt") + public void testExtValIntCharSequenceQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntCharSequenceQ.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValIntListQOfIntInClass.kt") + public void testExtValIntListQOfIntInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntListQOfIntInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValIntTInClass.kt") + public void testExtValIntTInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntTInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValIntTQInClass.kt") + public void testExtValIntTQInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValIntTQInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValTIntInClass.kt") + public void testExtValTIntInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtValTIntInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarClass.kt") + public void testExtVarClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarInClass.kt") + public void testExtVarInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarInt.kt") + public void testExtVarInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarInt.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarIntTInClass.kt") + public void testExtVarIntTInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarIntTInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarIntTQInClass.kt") + public void testExtVarIntTQInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarIntTQInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarMapPQInt.kt") + public void testExtVarMapPQInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarMapPQInt.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarTIntInClass.kt") + public void testExtVarTIntInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarTIntInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarTQIntInClass.kt") + public void testExtVarTQIntInClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarTQIntInClass.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarl.kt") + public void testExtVarl() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/ExtVarl.kt"); + doTest(fileName); + } + + @TestMetadata("NsVal.kt") + public void testNsVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/NsVal.kt"); + doTest(fileName); + } + + @TestMetadata("NsVar.kt") + public void testNsVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/NsVar.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideClassVal.kt") + public void testOverrideClassVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/OverrideClassVal.kt"); + doTest(fileName); + } + + @TestMetadata("OverrideTraitVal.kt") + public void testOverrideTraitVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/OverrideTraitVal.kt"); + doTest(fileName); + } + + @TestMetadata("PropFromSuperclass.kt") + public void testPropFromSuperclass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/PropFromSuperclass.kt"); + doTest(fileName); + } + + @TestMetadata("TraitFinalVar.kt") + public void testTraitFinalVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/TraitFinalVar.kt"); + doTest(fileName); + } + + @TestMetadata("TraitOpenVal.kt") + public void testTraitOpenVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/TraitOpenVal.kt"); + doTest(fileName); + } + + @TestMetadata("VarDelegationToTraitImpl.kt") + public void testVarDelegationToTraitImpl() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/VarDelegationToTraitImpl.kt"); + doTest(fileName); + } + + @TestMetadata("VarWithDelegated.kt") + public void testVarWithDelegated() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/VarWithDelegated.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultAccessors extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInDefaultAccessors() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("ClassVal.kt") + public void testClassVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVal.kt"); + doTest(fileName); + } + + @TestMetadata("ClassValParams.kt") + public void testClassValParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassValParams.kt"); + doTest(fileName); + } + + @TestMetadata("ClassValWithGet.kt") + public void testClassValWithGet() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassValWithGet.kt"); + doTest(fileName); + } + + @TestMetadata("ClassVar.kt") + public void testClassVar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVar.kt"); + doTest(fileName); + } + + @TestMetadata("ClassVarModality.kt") + public void testClassVarModality() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarModality.kt"); + doTest(fileName); + } + + @TestMetadata("ClassVarParams.kt") + public void testClassVarParams() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarParams.kt"); + doTest(fileName); + } + + @TestMetadata("ClassVarWithGet.kt") + public void testClassVarWithGet() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarWithGet.kt"); + doTest(fileName); + } + + @TestMetadata("ClassVarWithSet.kt") + public void testClassVarWithSet() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ClassVarWithSet.kt"); + doTest(fileName); + } + + @TestMetadata("ExtValLong.kt") + public void testExtValLong() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ExtValLong.kt"); + doTest(fileName); + } + + @TestMetadata("ExtVarLong.kt") + public void testExtVarLong() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors/ExtVarLong.kt"); + doTest(fileName); + } + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/type") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Type extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInType() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("Any.kt") + public void testAny() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Any.kt"); + doTest(fileName); + } + + @TestMetadata("AnyQ.kt") + public void testAnyQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/AnyQ.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayOfInNumber.kt") + public void testArrayOfInNumber() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfInNumber.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayOfInt.kt") + public void testArrayOfInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfInt.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayOfInteger.kt") + public void testArrayOfInteger() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfInteger.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayOfOutNumber.kt") + public void testArrayOfOutNumber() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfOutNumber.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayOfOutT.kt") + public void testArrayOfOutT() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfOutT.kt"); + doTest(fileName); + } + + @TestMetadata("ArrayOfString.kt") + public void testArrayOfString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ArrayOfString.kt"); + doTest(fileName); + } + + @TestMetadata("Function1IntString.kt") + public void testFunction1IntString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Function1IntString.kt"); + doTest(fileName); + } + + @TestMetadata("Int.kt") + public void testInt() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Int.kt"); + doTest(fileName); + } + + @TestMetadata("IntArray.kt") + public void testIntArray() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/IntArray.kt"); + doTest(fileName); + } + + @TestMetadata("IntQ.kt") + public void testIntQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/IntQ.kt"); + doTest(fileName); + } + + @TestMetadata("jlInteger.kt") + public void testJlInteger() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlInteger.kt"); + doTest(fileName); + } + + @TestMetadata("jlIntegerQ.kt") + public void testJlIntegerQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlIntegerQ.kt"); + doTest(fileName); + } + + @TestMetadata("jlNumber.kt") + public void testJlNumber() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlNumber.kt"); + doTest(fileName); + } + + @TestMetadata("jlObject.kt") + public void testJlObject() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlObject.kt"); + doTest(fileName); + } + + @TestMetadata("jlObjectQ.kt") + public void testJlObjectQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlObjectQ.kt"); + doTest(fileName); + } + + @TestMetadata("jlString.kt") + public void testJlString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlString.kt"); + doTest(fileName); + } + + @TestMetadata("jlStringQ.kt") + public void testJlStringQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/jlStringQ.kt"); + doTest(fileName); + } + + @TestMetadata("ListOfAny.kt") + public void testListOfAny() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfAny.kt"); + doTest(fileName); + } + + @TestMetadata("ListOfAnyQ.kt") + public void testListOfAnyQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfAnyQ.kt"); + doTest(fileName); + } + + @TestMetadata("ListOfStar.kt") + public void testListOfStar() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfStar.kt"); + doTest(fileName); + } + + @TestMetadata("ListOfString.kt") + public void testListOfString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfString.kt"); + doTest(fileName); + } + + @TestMetadata("ListOfjlString.kt") + public void testListOfjlString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/ListOfjlString.kt"); + doTest(fileName); + } + + @TestMetadata("Nothing.kt") + public void testNothing() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Nothing.kt"); + doTest(fileName); + } + + @TestMetadata("NothingQ.kt") + public void testNothingQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/NothingQ.kt"); + doTest(fileName); + } + + @TestMetadata("platform.kt") + public void testPlatform() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/platform.kt"); + doTest(fileName); + } + + @TestMetadata("String.kt") + public void testString() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/String.kt"); + doTest(fileName); + } + + @TestMetadata("StringQ.kt") + public void testStringQ() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/StringQ.kt"); + doTest(fileName); + } + + @TestMetadata("Unit.kt") + public void testUnit() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/type/Unit.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/loadJava/compiledKotlin/visibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Visibility extends AbstractJvmRuntimeDescriptorLoaderTest { + public void testAllFilesPresentInVisibility() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("InternalAbstractTraitMembersOverridden.kt") + public void testInternalAbstractTraitMembersOverridden() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalAbstractTraitMembersOverridden.kt"); + doTest(fileName); + } + + @TestMetadata("InternalClass.kt") + public void testInternalClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalClass.kt"); + doTest(fileName); + } + + @TestMetadata("InternalConstructor.kt") + public void testInternalConstructor() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("InternalTopLevelMembers.kt") + public void testInternalTopLevelMembers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalTopLevelMembers.kt"); + doTest(fileName); + } + + @TestMetadata("InternalTraitMembers.kt") + public void testInternalTraitMembers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalTraitMembers.kt"); + doTest(fileName); + } + + @TestMetadata("InternalTraitMembersInherited.kt") + public void testInternalTraitMembersInherited() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/InternalTraitMembersInherited.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateClass.kt") + public void testPrivateClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClass.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateClassMembers.kt") + public void testPrivateClassMembers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateClassMembers.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateToThis.kt") + public void testPrivateToThis() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateToThis.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateTopLevelFun.kt") + public void testPrivateTopLevelFun() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelFun.kt"); + doTest(fileName); + } + + @TestMetadata("PrivateTopLevelVal.kt") + public void testPrivateTopLevelVal() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PrivateTopLevelVal.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyInConstructor.kt") + public void testPropertyInConstructor() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PropertyInConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("PropertyInConstructorExplicitVisibility.kt") + public void testPropertyInConstructorExplicitVisibility() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/PropertyInConstructorExplicitVisibility.kt"); + doTest(fileName); + } + + @TestMetadata("TopLevelVarWithPrivateSetter.kt") + public void testTopLevelVarWithPrivateSetter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/loadJava/compiledKotlin/visibility/TopLevelVarWithPrivateSetter.kt"); + doTest(fileName); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt index c5faea96732..ab11105bc37 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil import org.jetbrains.kotlin.load.java.JvmAnnotationNames -import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.FqNameUnsafe -import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.load.java.structure.reflect.classId import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory @@ -83,15 +80,6 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() { ) } - private val Class<*>.classId: ClassId - get() { - if (getEnclosingMethod() != null || getEnclosingConstructor() != null) { - return ClassId(FqName.ROOT, FqNameUnsafe(getName()), /* local = */ true) - } - return getDeclaringClass()?.classId?.createNestedClassId(Name.identifier(getSimpleName())) - ?: ClassId.topLevel(FqName(getName())) - } - private fun assertHasAnnotationData(clazz: Class<*>) { [suppress("UNCHECKED_CAST")] val annotation = clazz.getAnnotation( diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalAnnotationResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalAnnotationResolver.java index 124f0a8e572..da7abdd5393 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalAnnotationResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalAnnotationResolver.java @@ -23,8 +23,23 @@ import org.jetbrains.kotlin.load.java.structure.JavaAnnotationOwner; import org.jetbrains.kotlin.name.FqName; import java.util.Collection; +import java.util.Collections; public interface ExternalAnnotationResolver { + ExternalAnnotationResolver EMPTY = new ExternalAnnotationResolver() { + @Nullable + @Override + public JavaAnnotation findExternalAnnotation(@NotNull JavaAnnotationOwner owner, @NotNull FqName fqName) { + return null; + } + + @NotNull + @Override + public Collection findExternalAnnotations(@NotNull JavaAnnotationOwner owner) { + return Collections.emptyList(); + } + }; + @Nullable JavaAnnotation findExternalAnnotation(@NotNull JavaAnnotationOwner owner, @NotNull FqName fqName); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java index afdb5df5462..338adf9e7d5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/ExternalSignatureResolver.java @@ -28,6 +28,53 @@ import java.util.Collections; import java.util.List; public interface ExternalSignatureResolver { + ExternalSignatureResolver DO_NOTHING = new ExternalSignatureResolver() { + @NotNull + @Override + public PropagatedMethodSignature resolvePropagatedSignature( + @NotNull JavaMethod method, + @NotNull ClassDescriptor owner, + @NotNull JetType returnType, + @Nullable JetType receiverType, + @NotNull List valueParameters, + @NotNull List typeParameters + ) { + return new PropagatedMethodSignature( + returnType, receiverType, valueParameters, typeParameters, Collections.emptyList(), false, + Collections.emptyList() + ); + } + + @NotNull + @Override + public AlternativeMethodSignature resolveAlternativeMethodSignature( + @NotNull JavaMember methodOrConstructor, + boolean hasSuperMethods, + @Nullable JetType returnType, + @Nullable JetType receiverType, + @NotNull List valueParameters, + @NotNull List typeParameters, + boolean hasStableParameterNames + ) { + return new AlternativeMethodSignature( + returnType, receiverType, valueParameters, typeParameters, Collections.emptyList(), hasStableParameterNames + ); + } + + @NotNull + @Override + public AlternativeFieldSignature resolveAlternativeFieldSignature( + @NotNull JavaField field, @NotNull JetType returnType, boolean isVar + ) { + return new AlternativeFieldSignature(returnType, null); + } + + @Override + public void reportSignatureErrors(@NotNull CallableMemberDescriptor descriptor, @NotNull List signatureErrors) { + throw new UnsupportedOperationException("Should not be called"); + } + }; + abstract class MemberSignature { private final List signatureErrors; diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaResolverCache.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaResolverCache.java index 3b825a6f16b..6b982077d3c 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaResolverCache.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaResolverCache.java @@ -29,6 +29,30 @@ import org.jetbrains.kotlin.load.java.structure.JavaMethod; import org.jetbrains.kotlin.name.FqName; public interface JavaResolverCache { + JavaResolverCache EMPTY = new JavaResolverCache() { + @Nullable + @Override + public ClassDescriptor getClassResolvedFromSource(@NotNull FqName fqName) { + return null; + } + + @Override + public void recordMethod(@NotNull JavaMethod method, @NotNull SimpleFunctionDescriptor descriptor) { + } + + @Override + public void recordConstructor(@NotNull JavaElement element, @NotNull ConstructorDescriptor descriptor) { + } + + @Override + public void recordField(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor) { + } + + @Override + public void recordClass(@NotNull JavaClass javaClass, @NotNull ClassDescriptor descriptor) { + } + }; + @Nullable ClassDescriptor getClassResolvedFromSource(@NotNull FqName fqName); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java index 3acd769be06..60ef7f6ebbd 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/MethodSignatureChecker.java @@ -24,6 +24,18 @@ import org.jetbrains.kotlin.load.java.structure.JavaMethod; import java.util.List; public interface MethodSignatureChecker { + MethodSignatureChecker DO_NOTHING = new MethodSignatureChecker() { + @Override + public void checkSignature( + @NotNull JavaMethod method, + boolean reportSignatureErrors, + @NotNull SimpleFunctionDescriptor descriptor, + @NotNull List signatureErrors, + @NotNull List superFunctions + ) { + } + }; + void checkSignature( @NotNull JavaMethod method, boolean reportSignatureErrors, diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt index e9ac4eafceb..00ed0af873a 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/SamConversionResolver.kt @@ -16,15 +16,23 @@ package org.jetbrains.kotlin.load.java.components -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.scopes.JetScope import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.types.JetType -import org.jetbrains.kotlin.load.java.structure.JavaMethod import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor +import org.jetbrains.kotlin.load.java.structure.JavaMethod +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.types.JetType public trait SamConversionResolver { + public default object EMPTY : SamConversionResolver { + override fun resolveSamAdapter(original: D) = null + override fun resolveSamConstructor(name: Name, scope: JetScope) = null + override fun resolveFunctionTypeIfSamInterface( + classDescriptor: JavaClassDescriptor, resolveMethod: (JavaMethod) -> FunctionDescriptor + ): JetType? = null + } + public fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor? public fun resolveSamAdapter(original: D): D? diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java index 90cdbe54576..d776e0de3c8 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaClassifierType.java @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.java.structure; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.ReadOnly; import java.util.Collection; import java.util.List; @@ -30,6 +31,7 @@ public interface JavaClassifierType extends JavaType { JavaTypeSubstitutor getSubstitutor(); @NotNull + @ReadOnly Collection getSupertypes(); @NotNull @@ -38,5 +40,6 @@ public interface JavaClassifierType extends JavaType { boolean isRaw(); @NotNull + @ReadOnly List getTypeArguments(); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java index 9587ca2a610..712bcb5c2a4 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaPropertyInitializerEvaluator.java @@ -22,6 +22,19 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor; import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant; public interface JavaPropertyInitializerEvaluator { + JavaPropertyInitializerEvaluator DO_NOTHING = new JavaPropertyInitializerEvaluator() { + @Nullable + @Override + public CompileTimeConstant getInitializerConstant(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor) { + return null; + } + + @Override + public boolean isNotNullCompileTimeConstant(@NotNull JavaField field) { + return false; + } + }; + @Nullable CompileTimeConstant getInitializerConstant(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java index 246eb79751b..17764d3f98a 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameter.java @@ -18,11 +18,13 @@ package org.jetbrains.kotlin.load.java.structure; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.ReadOnly; import java.util.Collection; public interface JavaTypeParameter extends JavaClassifier { @NotNull + @ReadOnly Collection getUpperBounds(); @Nullable diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameterListOwner.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameterListOwner.java index 43867dbe8ed..f7f011423bd 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameterListOwner.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/JavaTypeParameterListOwner.java @@ -17,10 +17,12 @@ package org.jetbrains.kotlin.load.java.structure; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.ReadOnly; import java.util.List; public interface JavaTypeParameterListOwner extends JavaElement { @NotNull + @ReadOnly List getTypeParameters(); } diff --git a/core/descriptors.runtime/descriptors.runtime.iml b/core/descriptors.runtime/descriptors.runtime.iml new file mode 100644 index 00000000000..0b3f5622cf0 --- /dev/null +++ b/core/descriptors.runtime/descriptors.runtime.iml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java b/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java new file mode 100644 index 00000000000..3c79d0ab25e --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java @@ -0,0 +1,112 @@ +/* + * Copyright 2010-2015 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.di; + +import org.jetbrains.kotlin.descriptors.ModuleDescriptor; +import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver; +import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver; +import org.jetbrains.kotlin.load.java.components.MethodSignatureChecker; +import org.jetbrains.kotlin.load.java.components.JavaResolverCache; +import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver; +import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator; +import org.jetbrains.kotlin.load.java.components.SamConversionResolver; +import org.jetbrains.kotlin.load.java.components.RuntimeErrorReporter; +import org.jetbrains.kotlin.load.java.components.RuntimeSourceElementFactory; +import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver; +import org.jetbrains.kotlin.storage.LockBasedStorageManager; +import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder; +import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClassFinder; +import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider; +import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext; +import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver; +import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava; +import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder; +import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl; +import org.jetbrains.annotations.NotNull; +import javax.annotation.PreDestroy; + +/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */ +@SuppressWarnings("all") +public class InjectorForRuntimeDescriptorLoader { + + private final ClassLoader classLoader; + private final ModuleDescriptor moduleDescriptor; + private final JavaDescriptorResolver javaDescriptorResolver; + private final ExternalSignatureResolver externalSignatureResolver; + private final MethodSignatureChecker methodSignatureChecker; + private final JavaResolverCache javaResolverCache; + private final ExternalAnnotationResolver externalAnnotationResolver; + private final JavaPropertyInitializerEvaluator javaPropertyInitializerEvaluator; + private final SamConversionResolver samConversionResolver; + private final RuntimeErrorReporter runtimeErrorReporter; + private final RuntimeSourceElementFactory runtimeSourceElementFactory; + private final SingleModuleClassResolver singleModuleClassResolver; + private final LockBasedStorageManager lockBasedStorageManager; + private final ReflectJavaClassFinder reflectJavaClassFinder; + private final ReflectKotlinClassFinder reflectKotlinClassFinder; + private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; + private final GlobalJavaResolverContext globalJavaResolverContext; + private final DeserializedDescriptorResolver deserializedDescriptorResolver; + private final DeserializationComponentsForJava deserializationComponentsForJava; + private final JavaClassDataFinder javaClassDataFinder; + private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader; + + public InjectorForRuntimeDescriptorLoader( + @NotNull ClassLoader classLoader, + @NotNull ModuleDescriptor moduleDescriptor + ) { + this.classLoader = classLoader; + this.moduleDescriptor = moduleDescriptor; + this.lockBasedStorageManager = new LockBasedStorageManager(); + this.reflectJavaClassFinder = new ReflectJavaClassFinder(classLoader); + this.reflectKotlinClassFinder = new ReflectKotlinClassFinder(classLoader); + this.runtimeErrorReporter = RuntimeErrorReporter.INSTANCE$; + this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(runtimeErrorReporter); + this.externalAnnotationResolver = ExternalAnnotationResolver.EMPTY; + this.externalSignatureResolver = ExternalSignatureResolver.DO_NOTHING; + this.methodSignatureChecker = MethodSignatureChecker.DO_NOTHING; + this.javaResolverCache = JavaResolverCache.EMPTY; + this.javaPropertyInitializerEvaluator = JavaPropertyInitializerEvaluator.DO_NOTHING; + this.samConversionResolver = SamConversionResolver.EMPTY; + this.runtimeSourceElementFactory = RuntimeSourceElementFactory.INSTANCE$; + this.singleModuleClassResolver = new SingleModuleClassResolver(); + this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver); + this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor()); + this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor()); + this.javaClassDataFinder = new JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver); + this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), lockBasedStorageManager, reflectKotlinClassFinder, runtimeErrorReporter); + this.deserializationComponentsForJava = new DeserializationComponentsForJava(lockBasedStorageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider); + + singleModuleClassResolver.setResolver(javaDescriptorResolver); + + deserializedDescriptorResolver.setComponents(deserializationComponentsForJava); + + } + + @PreDestroy + public void destroy() { + } + + public ModuleDescriptor getModuleDescriptor() { + return this.moduleDescriptor; + } + + public JavaDescriptorResolver getJavaDescriptorResolver() { + return this.javaDescriptorResolver; + } + +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeErrorReporter.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeErrorReporter.kt new file mode 100644 index 00000000000..438f3d57559 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeErrorReporter.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2015 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.load.java.components + +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.load.java.JvmAbi +import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass + +public object RuntimeErrorReporter : ErrorReporter { + // TODO: specialized exceptions + override fun reportIncompleteHierarchy(descriptor: ClassDescriptor, unresolvedSuperClasses: MutableList) { + throw IllegalStateException("Incomplete hierarchy for class ${descriptor.getName()}, unresolved classes $unresolvedSuperClasses") + } + + override fun reportIncompatibleAbiVersion(kotlinClass: KotlinJvmBinaryClass, actualVersion: Int) { + throw IllegalStateException("Incompatible ABI version of ${kotlinClass.getClassId()}: $actualVersion " + + "(expected version is ${JvmAbi.VERSION})") + } + + override fun reportCannotInferVisibility(descriptor: CallableMemberDescriptor) { + // TODO: use DescriptorRenderer + throw IllegalStateException("Cannot infer visibility for class ${descriptor.getName()}") + } + + override fun reportLoadingError(message: String, exception: Exception?) { + throw IllegalStateException(message, exception) + } +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeSourceElementFactory.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeSourceElementFactory.kt new file mode 100644 index 00000000000..858cf9b6f5a --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeSourceElementFactory.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2015 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.load.java.components + +import org.jetbrains.kotlin.load.java.sources.JavaSourceElement +import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory +import org.jetbrains.kotlin.load.java.structure.JavaElement +import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaElement + +// NOTE: currently source elements for descriptors at runtime are stored primarily for easier debugging experience. +// Consider not storing them if this proves to have significant performance implications +public object RuntimeSourceElementFactory : JavaSourceElementFactory { + private class RuntimeSourceElement(override val javaElement: ReflectJavaElement) : JavaSourceElement + + override fun source(javaElement: JavaElement) = RuntimeSourceElement(javaElement as ReflectJavaElement) +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/reflect/ReflectJavaClassFinder.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/reflect/ReflectJavaClassFinder.kt new file mode 100644 index 00000000000..ffd387160c8 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/reflect/ReflectJavaClassFinder.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2015 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.load.java.reflect + +import org.jetbrains.kotlin.load.java.JavaClassFinder +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.load.java.structure.JavaPackage +import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaClass +import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaPackage +import org.jetbrains.kotlin.name.ClassId + +public class ReflectJavaClassFinder(private val classLoader: ClassLoader) : JavaClassFinder { + override fun findClass(classId: ClassId): JavaClass? { + val klass = classLoader.tryLoadClass(classId.asSingleFqName().asString()) + return if (klass != null) ReflectJavaClass(klass) else null + } + + override fun findPackage(fqName: FqName): JavaPackage? { + // We don't know which packages our class loader has and has not, so we behave as if it contains any package in the world + return ReflectJavaPackage(fqName) + } +} + +fun ClassLoader.tryLoadClass(fqName: String) = + try { + loadClass(fqName) + } + catch (e: ClassNotFoundException) { + null + } diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt new file mode 100644 index 00000000000..652d56fbfad --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt @@ -0,0 +1,98 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import java.lang.reflect.Modifier +import org.jetbrains.kotlin.load.java.structure.* +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.utils.emptyOrSingletonList + +public class ReflectJavaClass(private val klass: Class<*>) : ReflectJavaElement(), JavaClass { + override fun getInnerClasses(): Collection { + // TODO + return listOf() + } + + override fun getFqName(): FqName? { + // TODO: can there be primitive types, arrays? + return getOuterClass()?.getFqName()?.child(Name.identifier(klass.getSimpleName())) ?: FqName(klass.getName()) + } + + override fun getOuterClass(): JavaClass? { + val container = klass.getDeclaringClass() + return if (container != null) ReflectJavaClass(container) else null + } + + override fun getSupertypes(): Collection { + // TODO: also call getSuperclass() / getInterfaces() for classes without generic signature + val supertypes = emptyOrSingletonList(klass.getGenericSuperclass()) + klass.getGenericInterfaces() + return supertypes.map { supertype -> ReflectJavaClassifierType(supertype) } + } + + override fun getMethods(): Collection { + // TODO + return listOf() + } + + override fun getFields(): Collection { + // TODO + return listOf() + } + + override fun getConstructors(): Collection { + // TODO + return listOf() + } + + override fun getDefaultType() = ReflectJavaClassifierType(klass) + + // TODO: drop OriginKind? + override fun getOriginKind() = JavaClass.OriginKind.COMPILED + + override fun createImmediateType(substitutor: JavaTypeSubstitutor): JavaType { + // TODO + throw UnsupportedOperationException() + } + + override fun getName(): Name { + // TODO: can there be primitive types, arrays? + return Name.identifier(klass.getSimpleName()) + } + + override fun getAnnotations(): Collection { + // TODO + return listOf() + } + + override fun findAnnotation(fqName: FqName): JavaAnnotation? { + // TODO + return null + } + + override fun getTypeParameters() = klass.getTypeParameters().map { ReflectJavaTypeParameter(it!!) } + + override fun isInterface() = klass.isInterface() + override fun isAnnotationType() = klass.isAnnotation() + override fun isEnum() = klass.isEnum() + + override fun isAbstract() = Modifier.isAbstract(klass.getModifiers()) + override fun isStatic() = Modifier.isStatic(klass.getModifiers()) + override fun isFinal() = Modifier.isFinal(klass.getModifiers()) + + override fun getVisibility() = calculateVisibility(klass.getModifiers()) +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt new file mode 100644 index 00000000000..41ff58708b7 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import org.jetbrains.kotlin.load.java.structure.JavaClassifier +import org.jetbrains.kotlin.load.java.structure.JavaClassifierType +import org.jetbrains.kotlin.load.java.structure.JavaType +import org.jetbrains.kotlin.load.java.structure.JavaTypeSubstitutor +import java.lang.reflect.ParameterizedType +import java.lang.reflect.Type +import java.lang.reflect.TypeVariable + +public class ReflectJavaClassifierType(val classifierType: Type) : ReflectJavaType(), JavaClassifierType { + override fun getClassifier(): JavaClassifier? { + return when (classifierType) { + is Class<*> -> ReflectJavaClass(classifierType) + is TypeVariable<*> -> ReflectJavaTypeParameter(classifierType) + // TODO + is ParameterizedType -> ReflectJavaClass(classifierType.getRawType() as Class<*>) + else -> throw UnsupportedOperationException("Unsupported type (${classifierType.javaClass}): $classifierType") + } + } + + override fun getSubstitutor(): JavaTypeSubstitutor = throw UnsupportedOperationException() + + override fun getSupertypes(): Collection = throw UnsupportedOperationException() + + override fun getPresentableText(): String = classifierType.toString() + + override fun isRaw(): Boolean = with(classifierType) { this is Class<*> && getTypeParameters().isNotEmpty() } + + override fun getTypeArguments(): List { + // TODO + return listOf() + } +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaElement.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaElement.kt new file mode 100644 index 00000000000..a76e78b9eb5 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaElement.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import org.jetbrains.kotlin.load.java.structure.JavaElement + +public abstract class ReflectJavaElement : JavaElement diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPackage.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPackage.kt new file mode 100644 index 00000000000..b44d6fdf393 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPackage.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.load.java.structure.JavaPackage +import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.name.Name + +public class ReflectJavaPackage(private val fqName: FqName) : ReflectJavaElement(), JavaPackage { + override fun getFqName() = fqName + + override fun getClasses(nameFilter: (Name) -> Boolean): Collection { + // A package at runtime can't know what classes it has and has not + return listOf() + } + + override fun getSubPackages(): Collection { + // A package at runtime can't know what sub packages it has and has not + return listOf() + } +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt new file mode 100644 index 00000000000..e543f2d1582 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import org.jetbrains.kotlin.load.java.structure.JavaType +import org.jetbrains.kotlin.load.java.structure.JavaArrayType + +public abstract class ReflectJavaType : JavaType { + override fun createArrayType(): JavaArrayType = throw UnsupportedOperationException() +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt new file mode 100644 index 00000000000..b354ba1e165 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import org.jetbrains.kotlin.load.java.structure.JavaType +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter +import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner +import org.jetbrains.kotlin.name.Name +import java.lang.reflect.TypeVariable + +public class ReflectJavaTypeParameter( + private val typeVariable: TypeVariable<*> +) : ReflectJavaElement(), JavaTypeParameter { + override fun getUpperBounds(): List { + val bounds = typeVariable.getBounds().map { bound -> ReflectJavaClassifierType(bound) } + if (bounds.singleOrNull()?.classifierType == javaClass()) return emptyList() + return bounds + } + + override fun getOwner(): JavaTypeParameterListOwner? { + // TODO + throw UnsupportedOperationException() + } + + override fun getType(): JavaType { + // TODO + throw UnsupportedOperationException() + } + + override fun getTypeProvider() = ReflectJavaTypeProvider + + override fun getName() = Name.identifier(typeVariable.getName()) + + override fun equals(other: Any?) = other is ReflectJavaTypeParameter && typeVariable == other.typeVariable + override fun hashCode() = typeVariable.hashCode() +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeProvider.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeProvider.kt new file mode 100644 index 00000000000..e0bc68db0f4 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeProvider.kt @@ -0,0 +1,42 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import org.jetbrains.kotlin.load.java.structure.JavaTypeProvider +import org.jetbrains.kotlin.load.java.structure.JavaType +import org.jetbrains.kotlin.load.java.structure.JavaWildcardType + +public object ReflectJavaTypeProvider : JavaTypeProvider { + override fun createJavaLangObjectType(): JavaType { + return ReflectJavaClassifierType(javaClass()) + } + + override fun createUpperBoundWildcard(bound: JavaType): JavaWildcardType { + // TODO + throw UnsupportedOperationException() + } + + override fun createLowerBoundWildcard(bound: JavaType): JavaWildcardType { + // TODO + throw UnsupportedOperationException() + } + + override fun createUnboundedWildcard(): JavaWildcardType { + // TODO + throw UnsupportedOperationException() + } +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/reflectStructureUtil.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/reflectStructureUtil.kt new file mode 100644 index 00000000000..d2e7524bc58 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/reflectStructureUtil.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2015 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.load.java.structure.reflect + +import java.lang.reflect.Modifier +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.load.java.JavaVisibilities +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.FqName + +private fun calculateVisibility(modifiers: Int): Visibility { + return when { + Modifier.isPublic(modifiers) -> Visibilities.PUBLIC + Modifier.isPrivate(modifiers) -> Visibilities.PRIVATE + Modifier.isProtected(modifiers) -> + if (Modifier.isStatic(modifiers)) JavaVisibilities.PROTECTED_STATIC_VISIBILITY else JavaVisibilities.PROTECTED_AND_PACKAGE + else -> JavaVisibilities.PACKAGE_VISIBILITY + } +} + +val Class<*>.classId: ClassId + get() = getDeclaringClass()?.classId?.createNestedClassId(Name.identifier(getSimpleName())) ?: ClassId.topLevel(FqName(getName())) diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt new file mode 100644 index 00000000000..0368419ee87 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt @@ -0,0 +1,55 @@ +/* + * Copyright 2010-2015 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.load.kotlin.reflect + +import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass +import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.load.java.structure.reflect.classId +import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor + +public class ReflectKotlinClass(private val klass: Class<*>) : KotlinJvmBinaryClass { + private val classHeader: KotlinClassHeader + + { + val headerReader = ReadKotlinClassHeaderAnnotationVisitor() + loadClassAnnotations(headerReader) + val header = headerReader.createHeader() + + if (header == null) { + // This exception must be caught in the caller + throw NotAKotlinClass() + } + + classHeader = header + } + + class NotAKotlinClass : RuntimeException() + + override fun getClassId(): ClassId = klass.classId + + override fun loadClassAnnotations(visitor: KotlinJvmBinaryClass.AnnotationVisitor) { + // TODO + visitor.visitEnd() + } + + override fun visitMembers(visitor: KotlinJvmBinaryClass.MemberVisitor) { + // TODO + } + + override fun getClassHeader() = classHeader +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClassFinder.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClassFinder.kt new file mode 100644 index 00000000000..59399c8e6ef --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClassFinder.kt @@ -0,0 +1,46 @@ +/* + * Copyright 2010-2015 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.load.kotlin.reflect + +import org.jetbrains.kotlin.load.java.reflect.tryLoadClass +import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder +import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass +import org.jetbrains.kotlin.name.ClassId + +public class ReflectKotlinClassFinder(private val classLoader: ClassLoader) : KotlinClassFinder { + private fun findKotlinClass(fqName: String): KotlinJvmBinaryClass? { + return classLoader.tryLoadClass(fqName)?.let { try { + ReflectKotlinClass(it) + } + catch (e: ReflectKotlinClass.NotAKotlinClass) { + null + } } + } + + override fun findKotlinClass(classId: ClassId) = findKotlinClass(classId.toRuntimeFqName()) + + override fun findKotlinClass(javaClass: JavaClass): KotlinJvmBinaryClass? { + // TODO: go through javaClass's class loader + return findKotlinClass(javaClass.getFqName()?.asString() ?: return null) + } +} + +private fun ClassId.toRuntimeFqName(): String { + val className = getRelativeClassName().asString().replace('.', '$') + return if (getPackageFqName().isRoot()) className else "${getPackageFqName()}.$className" +} diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt new file mode 100644 index 00000000000..a6416dc2e95 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt @@ -0,0 +1,39 @@ +/* + * Copyright 2010-2015 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.load.kotlin.reflect + +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.platform.JavaToKotlinClassMap +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.di.InjectorForRuntimeDescriptorLoader + +public class RuntimeModuleData private(private val injector: InjectorForRuntimeDescriptorLoader) { + public val module: ModuleDescriptor get() = injector.getModuleDescriptor() + + class object { + public fun create(classLoader: ClassLoader): RuntimeModuleData { + val module = ModuleDescriptorImpl(Name.special(""), listOf(), JavaToKotlinClassMap.INSTANCE) + module.addDependencyOnModule(module) + module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()) + val injector = InjectorForRuntimeDescriptorLoader(classLoader, module) + module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider) + return RuntimeModuleData(injector) + } + } +} diff --git a/core/reflection.jvm/reflection.jvm.iml b/core/reflection.jvm/reflection.jvm.iml index 5b59df0d759..abfedaaf6d2 100644 --- a/core/reflection.jvm/reflection.jvm.iml +++ b/core/reflection.jvm/reflection.jvm.iml @@ -7,6 +7,7 @@ + \ No newline at end of file diff --git a/generators/generators.iml b/generators/generators.iml index d0fa8fd3545..7947b675320 100644 --- a/generators/generators.iml +++ b/generators/generators.iml @@ -17,6 +17,7 @@ + @@ -27,5 +28,6 @@ + - + \ No newline at end of file diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 4a098bd6118..dc01ebe1e9d 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -17,43 +17,37 @@ package org.jetbrains.kotlin.generators.injectors import com.intellij.openapi.project.Project +import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.context.GlobalContext +import org.jetbrains.kotlin.context.LazyResolveToken import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl -import org.jetbrains.kotlin.resolve.* -import org.jetbrains.kotlin.load.java.JavaClassFinderImpl -import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver -import org.jetbrains.kotlin.load.java.components.* -import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl -import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder -import org.jetbrains.kotlin.resolve.lazy.ResolveSession -import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory -import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices import org.jetbrains.kotlin.generators.di.* -import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents -import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils -import org.jetbrains.kotlin.resolve.calls.CallResolver -import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl -import com.intellij.psi.search.GlobalSearchScope -import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver -import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava -import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver -import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory -import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider -import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer -import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider -import org.jetbrains.kotlin.context.LazyResolveToken -import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct -import org.jetbrains.kotlin.resolve.lazy.ScopeProvider import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider +import org.jetbrains.kotlin.load.java.JavaClassFinderImpl +import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider +import org.jetbrains.kotlin.load.java.components.* +import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver +import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver +import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder +import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl +import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator +import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl +import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava +import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider +import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder +import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory +import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClassFinder +import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.calls.CallResolver +import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver +import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct +import org.jetbrains.kotlin.resolve.lazy.* +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.types.DynamicTypesAllowed import org.jetbrains.kotlin.types.DynamicTypesSettings -import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider -import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider -import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer -import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder -import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer -import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver +import org.jetbrains.kotlin.types.expressions.* // NOTE: After making changes, you need to re-generate the injectors. // To do that, you can run main in this file. @@ -76,6 +70,7 @@ public fun createInjectorGenerators(): List = generatorForLazyTopDownAnalyzerBasic(), generatorForLazyLocalClassifierAnalyzer(), generatorForTopDownAnalyzerForJvm(), + generatorForRuntimeDescriptorLoader(), generatorForLazyResolveWithJava(), generatorForTopDownAnalyzerForJs(), generatorForMacro(), @@ -143,6 +138,29 @@ private fun generatorForTopDownAnalyzerForJvm() = commonForJavaTopDownAnalyzer() } +private fun generatorForRuntimeDescriptorLoader() = + generator("core/descriptors.runtime/src", DI_DEFAULT_PACKAGE, "InjectorForRuntimeDescriptorLoader") { + parameter() + publicParameter() + + publicField() + + field(init = GetSingleton.byField(javaClass(), "DO_NOTHING")) + field(init = GetSingleton.byField(javaClass(), "DO_NOTHING")) + field(init = GetSingleton.byField(javaClass(), "EMPTY")) + field(init = GetSingleton.byField(javaClass(), "EMPTY")) + field(init = GetSingleton.byField(javaClass(), "DO_NOTHING")) + field(init = GetSingleton.byField(javaClass(), "EMPTY")) + + field() + field() + field() + + field() + field() + field() + } + private fun generatorForLazyResolveWithJava() = generator("compiler/frontend.java/src", DI_DEFAULT_PACKAGE, "InjectorForLazyResolveWithJava") { commonForResolveSessionBased() diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index a48f9264021..a50ae06da3d 100644 --- a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -94,6 +94,7 @@ import org.jetbrains.kotlin.jvm.compiler.AbstractCompileJavaAgainstKotlinTest import org.jetbrains.kotlin.jvm.compiler.AbstractCompileKotlinAgainstKotlinTest import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJavaTest import org.jetbrains.kotlin.jvm.compiler.AbstractWriteSignatureTest +import org.jetbrains.kotlin.jvm.runtime.AbstractJvmRuntimeDescriptorLoaderTest import org.jetbrains.kotlin.lang.resolve.android.test.AbstractAndroidBoxTest import org.jetbrains.kotlin.lang.resolve.android.test.AbstractAndroidBytecodeShapeTest import org.jetbrains.kotlin.lang.resolve.android.test.AbstractAndroidXml2KConversionTest @@ -218,6 +219,10 @@ fun main(args: Array) { model("loadJava/sourceJava", extension = "java", testMethod = "doTestSourceJava") } + testClass(javaClass()) { + model("loadJava/compiledKotlin") + } + testClass(javaClass()) { model("compileJavaAgainstKotlin") }