diff --git a/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt b/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt index c4d52161313..7c3d2276550 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER +// SKIP_COMPILED_JAVA // FILE: A.java import org.checkerframework.checker.nullness.qual.*; diff --git a/compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt b/compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt index 86c6c7bae33..400ea2b2db7 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt @@ -1,4 +1,5 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER +// SKIP_COMPILED_JAVA // FILE: A.java import org.eclipse.jdt.annotation.*; diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt index c893b630359..6dab460b47e 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt @@ -1,5 +1,6 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER // SKIP_JAVAC +// SKIP_COMPILED_JAVA // FILE: spr/NonNullApi.java diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt new file mode 100644 index 00000000000..f42f4703406 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt @@ -0,0 +1,70 @@ +// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER +// SKIP_JAVAC +// SKIP_COMPILED_JAVA + +// FILE: spr/NonNullApi.java + +package spr; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import javax.annotation.Nonnull; +import javax.annotation.meta.TypeQualifierDefault; + +@Target({ElementType.TYPE_USE}) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Nonnull +@TypeQualifierDefault({ElementType.TYPE_USE}) +public @interface NonNullApi { +} + +// FILE: spr/NullableApi.java + +package spr; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import javax.annotation.Nonnull; +import javax.annotation.meta.TypeQualifierDefault; +import javax.annotation.meta.When; + +@Target({ElementType.TYPE, ElementType.TYPE_USE}) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Nonnull(when = When.MAYBE) +@TypeQualifierDefault({ElementType.TYPE_USE}) +public @interface NullableApi { +} + +// FILE: A.java + +import spr.*; +import java.util.*; + +@NonNullApi +public class A { + public String foo(String x) { return ""; } + public @NullableApi String bar(@NullableApi String y) { return ""; } + public @NullableApi List baz1() { return null; } +} + +// FILE: main.kt + +fun main(a: A) { + a.foo("").length + a.foo(null)?.length + + a.bar("").length + a.bar(null)?.length + + a.baz1().get(0).length + a.baz1()!!.get(0).length + a.baz1()!!.get(0)?.length +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.txt b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.txt new file mode 100644 index 00000000000..464ab11573e --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.txt @@ -0,0 +1,30 @@ +package + +public fun main(/*0*/ a: A): kotlin.Unit + +@spr.NonNullApi public open class A { + public constructor A() + @spr.NullableApi public open fun bar(/*0*/ @spr.NullableApi y: @spr.NullableApi kotlin.String?): @spr.NullableApi kotlin.String? + @spr.NullableApi public open fun baz1(): (@spr.NullableApi kotlin.collections.MutableList?..@spr.NullableApi kotlin.collections.List?) + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open fun foo(/*0*/ x: kotlin.String): kotlin.String + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +package spr { + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NonNullApi : kotlin.Annotation { + public constructor NonNullApi() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE, AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented @javax.annotation.Nonnull(when = When.MAYBE) @javax.annotation.meta.TypeQualifierDefault(value = {ElementType.TYPE_USE}) public final annotation class NullableApi : kotlin.Annotation { + public constructor NullableApi() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt index e908cf5b099..16c24caa4fb 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt @@ -1,5 +1,6 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER // RENDER_PACKAGE: test +// SKIP_COMPILED_JAVA // FILE: spr/Nullable.java diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt index adb2de504d5..f9b0196f55b 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt @@ -1,3 +1,4 @@ +// SKIP_COMPILED_JAVA // FILE: Base.java public interface Base {} // FILE: A.java diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java new file mode 100644 index 00000000000..9e2d1b7cc9e --- /dev/null +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java @@ -0,0 +1,122 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/foreignAnnotationsJava8/tests") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest { + public void testAllFilesPresentInTests() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("checkerFramework.kt") + public void testCheckerFramework() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt"); + doTest(fileName); + } + + @TestMetadata("eclipse.kt") + public void testEclipse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Jsr305 extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest { + public void testAllFilesPresentInJsr305() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("defaultAnnotationAppliedToType.kt") + public void testDefaultAnnotationAppliedToType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt"); + doTest(fileName); + } + + @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt") + public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt"); + doTest(fileName); + } + + @TestMetadata("springNullableWithTypeUse.kt") + public void testSpringNullableWithTypeUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt"); + doTest(fileName); + } + + @TestMetadata("typeArguments.kt") + public void testTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancement extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest { + public void testAllFilesPresentInTypeEnhancement() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotatedTypeArguments.kt") + public void testAnnotatedTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("methodWithTypeParameter.kt") + public void testMethodWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeDifferentConstructor.kt") + public void testReturnTypeDifferentConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeOverrideInKotlin.kt") + public void testReturnTypeOverrideInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); + doTest(fileName); + } + } +} diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java new file mode 100644 index 00000000000..55cfc358e17 --- /dev/null +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated.java @@ -0,0 +1,122 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.checkers; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/foreignAnnotationsJava8/tests") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class ForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTestGenerated extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest { + public void testAllFilesPresentInTests() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("checkerFramework.kt") + public void testCheckerFramework() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.kt"); + doTest(fileName); + } + + @TestMetadata("eclipse.kt") + public void testEclipse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/eclipse.kt"); + doTest(fileName); + } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Jsr305 extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest { + public void testAllFilesPresentInJsr305() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("defaultAnnotationAppliedToType.kt") + public void testDefaultAnnotationAppliedToType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToType.kt"); + doTest(fileName); + } + + @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt") + public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt"); + doTest(fileName); + } + + @TestMetadata("springNullableWithTypeUse.kt") + public void testSpringNullableWithTypeUse() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt"); + doTest(fileName); + } + + @TestMetadata("typeArguments.kt") + public void testTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/typeArguments.kt"); + doTest(fileName); + } + } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancement extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest { + public void testAllFilesPresentInTypeEnhancement() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("annotatedTypeArguments.kt") + public void testAnnotatedTypeArguments() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.kt"); + doTest(fileName); + } + + @TestMetadata("methodWithTypeParameter.kt") + public void testMethodWithTypeParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeDifferentConstructor.kt") + public void testReturnTypeDifferentConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.kt"); + doTest(fileName); + } + + @TestMetadata("returnTypeOverrideInKotlin.kt") + public void testReturnTypeOverrideInKotlin() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.kt"); + doTest(fileName); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); + doTest(fileName); + } + } +} diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java index 44628460eec..be60ddb5e36 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java @@ -62,6 +62,12 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An doTest(fileName); } + @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt") + public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt"); + doTest(fileName); + } + @TestMetadata("springNullableWithTypeUse.kt") public void testSpringNullableWithTypeUse() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt"); diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java index 00046c3dacf..b54e4241237 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java @@ -62,6 +62,12 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore doTest(fileName); } + @TestMetadata("defaultAnnotationAppliedToTypeForCompiledJava.kt") + public void testDefaultAnnotationAppliedToTypeForCompiledJava() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/defaultAnnotationAppliedToTypeForCompiledJava.kt"); + doTest(fileName); + } + @TestMetadata("springNullableWithTypeUse.kt") public void testSpringNullableWithTypeUse() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/foreignAnnotationsJava8/tests/jsr305/springNullableWithTypeUse.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignJava8AnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignJava8AnnotationsTest.kt index 8556fbc5059..edc620bf577 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignJava8AnnotationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractForeignJava8AnnotationsTest.kt @@ -16,7 +16,36 @@ package org.jetbrains.kotlin.checkers +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import java.io.File + abstract class AbstractForeignJava8AnnotationsTest : AbstractForeignAnnotationsTest() { override val annotationsPath: String - get() = "third-party/jdk8-annotations" + get() = JAVA8_ANNOTATION_SOURCES_PATH } + +abstract class AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest : AbstractForeignAnnotationsNoAnnotationInClasspathTest() { + override val annotationsPath: String + get() = JAVA8_ANNOTATION_SOURCES_PATH + + override fun analyzeAndCheck(testDataFile: File, files: List) { + if (skipForCompiledVersion(files)) return + super.analyzeAndCheck(testDataFile, files) + } +} + +abstract class AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithFastClassReadingTest : AbstractForeignAnnotationsNoAnnotationInClasspathWithFastClassReadingTest() { + override val annotationsPath: String + get() = JAVA8_ANNOTATION_SOURCES_PATH + + override fun analyzeAndCheck(testDataFile: File, files: List) { + if (skipForCompiledVersion(files)) return + super.analyzeAndCheck(testDataFile, files) + } +} + +private fun skipForCompiledVersion(files: List) = + files.any { file -> InTextDirectivesUtils.isDirectiveDefined(file.expectedText, "// SKIP_COMPILED_JAVA") } + + +private const val JAVA8_ANNOTATION_SOURCES_PATH = "third-party/jdk8-annotations" diff --git a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 1790e86d898..c8ddc452674 100755 --- a/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/src/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -517,6 +517,14 @@ fun main(args: Array) { model("foreignAnnotationsJava8/tests") } + testClass { + model("foreignAnnotationsJava8/tests") + } + + testClass { + model("foreignAnnotationsJava8/tests") + } + testClass { model("loadJava8/compiledJava", extension = "java", testMethod = "doTestCompiledJava") model("loadJava8/sourceJava", extension = "java", testMethod = "doTestSourceJava")