diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 871c3856ca1..cb030dad67f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import com.intellij.psi.HierarchicalMethodSignature; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiType; @@ -135,6 +136,20 @@ public final class JavaFunctionResolver { .resolveParameterDescriptors(functionDescriptorImpl, method.getParameters(), methodTypeVariableResolver); JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver); + + Set typesFromSuperMethods = Sets.newHashSet(); + for (HierarchicalMethodSignature superSignature : method.getPsiMethod().getHierarchicalMethodSignature().getSuperSignatures()) { + DeclarationDescriptor superFun = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, superSignature.getMethod()); + if (superFun instanceof FunctionDescriptor) { + typesFromSuperMethods.add(((FunctionDescriptor) superFun).getReturnType()); + } + } + typesFromSuperMethods.add(returnType); + JetType intersectionType = TypeUtils.intersect(JetTypeChecker.INSTANCE, typesFromSuperMethods); + if (intersectionType != null && intersectionType.getConstructor().getDeclarationDescriptor() != null) { + returnType = intersectionType; + } + // TODO consider better place for this check AlternativeMethodSignatureData alternativeMethodSignatureData = new AlternativeMethodSignatureData(method, valueParameterDescriptors, returnType, methodTypeParameters); diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java new file mode 100644 index 00000000000..0e05b6fba58 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java @@ -0,0 +1,19 @@ +package test; + +import org.jetbrains.annotations.NotNull; +import java.lang.CharSequence; + +import jet.runtime.typeinfo.KotlinSignature; + +public class AddNotNullJavaSubtype { + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + + public class Sub extends AddNotNullJavaSubtype { + @NotNull + public String foo() { + throw new UnsupportedOperationException(); + } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt new file mode 100644 index 00000000000..e6b37eaa4fe --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt @@ -0,0 +1,11 @@ +package test + +import org.jetbrains.annotations.NotNull + +public open class AddNotNullJavaSubtype : java.lang.Object() { + public open fun foo(): CharSequence? = throw UnsupportedOperationException() + + public open class Sub: AddNotNullJavaSubtype() { + override fun foo(): String = throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt new file mode 100644 index 00000000000..d655363e8f0 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.txt @@ -0,0 +1,10 @@ +namespace test + +public open class test.AddNotNullJavaSubtype : java.lang.Object { + public final /*constructor*/ fun (): test.AddNotNullJavaSubtype + public open fun foo(): jet.CharSequence? + public open class test.AddNotNullJavaSubtype.Sub : test.AddNotNullJavaSubtype { + public final /*constructor*/ fun (): test.AddNotNullJavaSubtype.Sub + public open override /*1*/ fun foo(): jet.String + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.java new file mode 100644 index 00000000000..ad9d9a91b2c --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.java @@ -0,0 +1,19 @@ +package test; + +import org.jetbrains.annotations.NotNull; +import java.lang.CharSequence; + +import jet.runtime.typeinfo.KotlinSignature; + +public class AddNotNullSameJavaType { + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + + public class Sub extends AddNotNullSameJavaType { + @NotNull + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt new file mode 100644 index 00000000000..2e2cadf8e50 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt @@ -0,0 +1,11 @@ +package test + +import org.jetbrains.annotations.NotNull + +public open class AddNotNullSameJavaType : java.lang.Object() { + public open fun foo(): CharSequence? = throw UnsupportedOperationException() + + public open class Sub: AddNotNullSameJavaType() { + override fun foo(): CharSequence = throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt new file mode 100644 index 00000000000..cfd5be7c7b3 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.txt @@ -0,0 +1,10 @@ +namespace test + +public open class test.AddNotNullSameJavaType : java.lang.Object { + public final /*constructor*/ fun (): test.AddNotNullSameJavaType + public open fun foo(): jet.CharSequence? + public open class test.AddNotNullSameJavaType.Sub : test.AddNotNullSameJavaType { + public final /*constructor*/ fun (): test.AddNotNullSameJavaType.Sub + public open override /*1*/ fun foo(): jet.CharSequence + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java new file mode 100644 index 00000000000..ac8fa435afb --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java @@ -0,0 +1,20 @@ +package test; + +import org.jetbrains.annotations.NotNull; +import java.lang.CharSequence; + +import jet.runtime.typeinfo.KotlinSignature; + +public class AddNullabilityJavaSubtype { + @NotNull + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + + public class Sub extends AddNullabilityJavaSubtype { + @KotlinSignature("fun String? foo()") + public String foo() { + throw new UnsupportedOperationException(); + } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt new file mode 100644 index 00000000000..94564d37760 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt @@ -0,0 +1,11 @@ +package test + +import org.jetbrains.annotations.NotNull + +public open class AddNullabilityJavaSubtype : java.lang.Object() { + public open fun foo(): CharSequence = throw UnsupportedOperationException() + + public open class Sub: AddNullabilityJavaSubtype() { + override fun foo(): String = throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt new file mode 100644 index 00000000000..76fcadbc6dd --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.txt @@ -0,0 +1,10 @@ +namespace test + +public open class test.AddNullabilityJavaSubtype : java.lang.Object { + public final /*constructor*/ fun (): test.AddNullabilityJavaSubtype + public open fun foo(): jet.CharSequence + public open class test.AddNullabilityJavaSubtype.Sub : test.AddNullabilityJavaSubtype { + public final /*constructor*/ fun (): test.AddNullabilityJavaSubtype.Sub + public open override /*1*/ fun foo(): jet.String + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java new file mode 100644 index 00000000000..94c1f63568b --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java @@ -0,0 +1,20 @@ +package test; + +import org.jetbrains.annotations.NotNull; +import java.lang.CharSequence; + +import jet.runtime.typeinfo.KotlinSignature; + +public class AddNullabilitySameJavaType { + @NotNull + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + + public class Sub extends AddNullabilitySameJavaType { + @KotlinSignature("fun CharSequence? foo()") + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt new file mode 100644 index 00000000000..82a06227d14 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt @@ -0,0 +1,11 @@ +package test + +import org.jetbrains.annotations.NotNull + +public open class AddNullabilitySameJavaType : java.lang.Object() { + public open fun foo(): CharSequence = throw UnsupportedOperationException() + + public open class Sub: AddNullabilitySameJavaType() { + override fun foo(): CharSequence = throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt new file mode 100644 index 00000000000..67be8ff6043 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.txt @@ -0,0 +1,10 @@ +namespace test + +public open class test.AddNullabilitySameJavaType : java.lang.Object { + public final /*constructor*/ fun (): test.AddNullabilitySameJavaType + public open fun foo(): jet.CharSequence + public open class test.AddNullabilitySameJavaType.Sub : test.AddNullabilitySameJavaType { + public final /*constructor*/ fun (): test.AddNullabilitySameJavaType.Sub + public open override /*1*/ fun foo(): jet.CharSequence + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java new file mode 100644 index 00000000000..ed69d6756e4 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java @@ -0,0 +1,19 @@ +package test; + +import org.jetbrains.annotations.NotNull; +import java.lang.CharSequence; + +import jet.runtime.typeinfo.KotlinSignature; + +public class InheritNullabilityJavaSubtype { + @NotNull + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + + public class Sub extends InheritNullabilityJavaSubtype { + public String foo() { + throw new UnsupportedOperationException(); + } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt new file mode 100644 index 00000000000..1e86c2f6b40 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt @@ -0,0 +1,11 @@ +package test + +import org.jetbrains.annotations.NotNull + +public open class InheritNullabilityJavaSubtype : java.lang.Object() { + public open fun foo(): CharSequence = throw UnsupportedOperationException() + + public open class Sub: InheritNullabilityJavaSubtype() { + override fun foo(): String = throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt new file mode 100644 index 00000000000..3182223dc07 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.txt @@ -0,0 +1,10 @@ +namespace test + +public open class test.InheritNullabilityJavaSubtype : java.lang.Object { + public final /*constructor*/ fun (): test.InheritNullabilityJavaSubtype + public open fun foo(): jet.CharSequence + public open class test.InheritNullabilityJavaSubtype.Sub : test.InheritNullabilityJavaSubtype { + public final /*constructor*/ fun (): test.InheritNullabilityJavaSubtype.Sub + public open override /*1*/ fun foo(): jet.String + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java new file mode 100644 index 00000000000..e8864a494bd --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java @@ -0,0 +1,19 @@ +package test; + +import org.jetbrains.annotations.NotNull; +import java.lang.CharSequence; + +import jet.runtime.typeinfo.KotlinSignature; + +public class InheritNullabilitySameJavaType { + @NotNull + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + + public class Sub extends InheritNullabilitySameJavaType { + public CharSequence foo() { + throw new UnsupportedOperationException(); + } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt new file mode 100644 index 00000000000..2f2dacdc73c --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt @@ -0,0 +1,11 @@ +package test + +import org.jetbrains.annotations.NotNull + +public open class InheritNullabilitySameJavaType : java.lang.Object() { + public open fun foo(): CharSequence = throw UnsupportedOperationException() + + public open class Sub: InheritNullabilitySameJavaType() { + override fun foo(): CharSequence = throw UnsupportedOperationException() + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt new file mode 100644 index 00000000000..a7122b8f382 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.txt @@ -0,0 +1,10 @@ +namespace test + +public open class test.InheritNullabilitySameJavaType : java.lang.Object { + public final /*constructor*/ fun (): test.InheritNullabilitySameJavaType + public open fun foo(): jet.CharSequence + public open class test.InheritNullabilitySameJavaType.Sub : test.InheritNullabilitySameJavaType { + public final /*constructor*/ fun (): test.InheritNullabilitySameJavaType.Sub + public open override /*1*/ fun foo(): jet.CharSequence + } +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index 0a6c0963bcf..0f8c480a597 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java @@ -234,7 +234,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } @TestMetadata("compiler/testData/loadJava/kotlinSignature") - @InnerTestClasses({KotlinSignature.Error.class}) + @InnerTestClasses({KotlinSignature.Error.class, KotlinSignature.Propagation.class}) public static class KotlinSignature extends AbstractLoadJavaTest { public void testAllFilesPresentInKotlinSignature() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature"), "java", true); @@ -433,10 +433,64 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } + @TestMetadata("compiler/testData/loadJava/kotlinSignature/propagation") + @InnerTestClasses({Propagation.Return.class}) + public static class Propagation extends AbstractLoadJavaTest { + public void testAllFilesPresentInPropagation() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/propagation"), "java", true); + } + + @TestMetadata("compiler/testData/loadJava/kotlinSignature/propagation/return") + public static class Return extends AbstractLoadJavaTest { + @TestMetadata("AddNotNullJavaSubtype.java") + public void testAddNotNullJavaSubtype() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.java"); + } + + @TestMetadata("AddNotNullSameJavaType.java") + public void testAddNotNullSameJavaType() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.java"); + } + + @TestMetadata("AddNullabilityJavaSubtype.java") + public void testAddNullabilityJavaSubtype() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.java"); + } + + @TestMetadata("AddNullabilitySameJavaType.java") + public void testAddNullabilitySameJavaType() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.java"); + } + + public void testAllFilesPresentInReturn() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/propagation/return"), "java", true); + } + + @TestMetadata("InheritNullabilityJavaSubtype.java") + public void testInheritNullabilityJavaSubtype() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.java"); + } + + @TestMetadata("InheritNullabilitySameJavaType.java") + public void testInheritNullabilitySameJavaType() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.java"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Propagation"); + suite.addTestSuite(Propagation.class); + suite.addTestSuite(Return.class); + return suite; + } + } + public static Test innerSuite() { TestSuite suite = new TestSuite("KotlinSignature"); suite.addTestSuite(KotlinSignature.class); suite.addTestSuite(Error.class); + suite.addTest(Propagation.innerSuite()); return suite; } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index 21f64219f5f..cedb6bd6eb4 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -1129,7 +1129,7 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso } @TestMetadata("compiler/testData/loadJava/kotlinSignature") - @InnerTestClasses({KotlinSignature.Error.class}) + @InnerTestClasses({KotlinSignature.Error.class, KotlinSignature.Propagation.class}) public static class KotlinSignature extends AbstractLazyResolveNamespaceComparingTest { public void testAllFilesPresentInKotlinSignature() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature"), "kt", true); @@ -1328,10 +1328,64 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso } + @TestMetadata("compiler/testData/loadJava/kotlinSignature/propagation") + @InnerTestClasses({Propagation.Return.class}) + public static class Propagation extends AbstractLazyResolveNamespaceComparingTest { + public void testAllFilesPresentInPropagation() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/propagation"), "kt", true); + } + + @TestMetadata("compiler/testData/loadJava/kotlinSignature/propagation/return") + public static class Return extends AbstractLazyResolveNamespaceComparingTest { + @TestMetadata("AddNotNullJavaSubtype.kt") + public void testAddNotNullJavaSubtype() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullJavaSubtype.kt"); + } + + @TestMetadata("AddNotNullSameJavaType.kt") + public void testAddNotNullSameJavaType() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNotNullSameJavaType.kt"); + } + + @TestMetadata("AddNullabilityJavaSubtype.kt") + public void testAddNullabilityJavaSubtype() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilityJavaSubtype.kt"); + } + + @TestMetadata("AddNullabilitySameJavaType.kt") + public void testAddNullabilitySameJavaType() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/AddNullabilitySameJavaType.kt"); + } + + public void testAllFilesPresentInReturn() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadJava/kotlinSignature/propagation/return"), "kt", true); + } + + @TestMetadata("InheritNullabilityJavaSubtype.kt") + public void testInheritNullabilityJavaSubtype() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilityJavaSubtype.kt"); + } + + @TestMetadata("InheritNullabilitySameJavaType.kt") + public void testInheritNullabilitySameJavaType() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/propagation/return/InheritNullabilitySameJavaType.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Propagation"); + suite.addTestSuite(Propagation.class); + suite.addTestSuite(Return.class); + return suite; + } + } + public static Test innerSuite() { TestSuite suite = new TestSuite("KotlinSignature"); suite.addTestSuite(KotlinSignature.class); suite.addTestSuite(Error.class); + suite.addTest(Propagation.innerSuite()); return suite; } }