diff --git a/compiler/testData/foreignAnnotations/tests/jsr305NullabilityNicknames.txt b/compiler/testData/foreignAnnotations/tests/jsr305NullabilityNicknames.txt index 5c5e7e7a02e..7076e2dfb33 100644 --- a/compiler/testData/foreignAnnotations/tests/jsr305NullabilityNicknames.txt +++ b/compiler/testData/foreignAnnotations/tests/jsr305NullabilityNicknames.txt @@ -4,10 +4,10 @@ public fun main(/*0*/ a: A): kotlin.Unit public open class A { public constructor A() - @MyNullable public final var field: @MyNullable kotlin.String? - @MyNonnull public open fun bar(): @MyNonnull kotlin.String + @MyNullable public final var field: kotlin.String? + @MyNonnull public open fun bar(): kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @MyNullable public open fun foo(/*0*/ @MyNonnull x: @MyNonnull kotlin.String, /*1*/ @MyNullable y: @MyNullable kotlin.CharSequence?): @MyNullable kotlin.String? + @MyNullable public open fun foo(/*0*/ @MyNonnull x: kotlin.String, /*1*/ @MyNullable y: kotlin.CharSequence?): kotlin.String? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.txt b/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.txt index dadab74fad8..13b4adbf6cf 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/checkerFramework.txt @@ -4,11 +4,11 @@ public fun main(/*0*/ a: A, /*1*/ a1: A): kotlin. public open class A { public constructor A() - @org.checkerframework.checker.nullness.qual.Nullable public final var field: kotlin.String? - @org.checkerframework.checker.nullness.qual.NonNull public open fun bar(): kotlin.String - @org.checkerframework.checker.nullness.qual.Nullable public open fun baz(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: T): T? + @org.checkerframework.checker.nullness.qual.Nullable public final var field: @org.checkerframework.checker.nullness.qual.Nullable kotlin.String? + @org.checkerframework.checker.nullness.qual.NonNull public open fun bar(): @org.checkerframework.checker.nullness.qual.NonNull kotlin.String + @org.checkerframework.checker.nullness.qual.Nullable public open fun baz(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull T): @org.checkerframework.checker.nullness.qual.Nullable T? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @org.checkerframework.checker.nullness.qual.Nullable public open fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: kotlin.String, /*1*/ @org.checkerframework.checker.nullness.qual.Nullable y: kotlin.CharSequence?): kotlin.String? + @org.checkerframework.checker.nullness.qual.Nullable public open fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull kotlin.String, /*1*/ @org.checkerframework.checker.nullness.qual.Nullable y: @org.checkerframework.checker.nullness.qual.Nullable kotlin.CharSequence?): @org.checkerframework.checker.nullness.qual.Nullable kotlin.String? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/eclipse.txt b/compiler/testData/foreignAnnotationsJava8/tests/eclipse.txt index d73832edc45..45024983b72 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/eclipse.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/eclipse.txt @@ -4,11 +4,11 @@ public fun main(/*0*/ a: A, /*1*/ a1: A): kotlin. public open class A { public constructor A() - @org.eclipse.jdt.annotation.Nullable public final var field: kotlin.String? - @org.eclipse.jdt.annotation.NonNull public open fun bar(): kotlin.String - @org.eclipse.jdt.annotation.Nullable public open fun baz(/*0*/ @org.eclipse.jdt.annotation.NonNull x: T): T? + @org.eclipse.jdt.annotation.Nullable public final var field: @org.eclipse.jdt.annotation.Nullable kotlin.String? + @org.eclipse.jdt.annotation.NonNull public open fun bar(): @org.eclipse.jdt.annotation.NonNull kotlin.String + @org.eclipse.jdt.annotation.Nullable public open fun baz(/*0*/ @org.eclipse.jdt.annotation.NonNull x: @org.eclipse.jdt.annotation.NonNull T): @org.eclipse.jdt.annotation.Nullable T? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @org.eclipse.jdt.annotation.Nullable public open fun foo(/*0*/ @org.eclipse.jdt.annotation.NonNull x: kotlin.String, /*1*/ @org.eclipse.jdt.annotation.Nullable y: kotlin.CharSequence?): kotlin.String? + @org.eclipse.jdt.annotation.Nullable public open fun foo(/*0*/ @org.eclipse.jdt.annotation.NonNull x: @org.eclipse.jdt.annotation.NonNull kotlin.String, /*1*/ @org.eclipse.jdt.annotation.Nullable y: @org.eclipse.jdt.annotation.Nullable kotlin.CharSequence?): @org.eclipse.jdt.annotation.Nullable kotlin.String? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.txt index 03461073601..9cee33afe67 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/annotatedTypeArguments.txt @@ -17,7 +17,7 @@ public/*package*/ open class AnnotatedTypeArguments { public/*package*/ open inner class B : AnnotatedTypeArguments.A { public/*package*/ constructor B() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: L, S<*>>!>): L, S<*>>!>? + @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull L, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>): @org.checkerframework.checker.nullness.qual.Nullable L, @org.checkerframework.checker.nullness.qual.NonNull S<*>>!>? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -33,7 +33,7 @@ public/*package*/ open class AnnotatedTypeArguments { public/*package*/ open inner class D1 : AnnotatedTypeArguments.C { public/*package*/ constructor D1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public/*package*/ open override /*1*/ fun foo(/*0*/ x: L, S<*>>!>): L, S<*>>!>? + public/*package*/ open override /*1*/ fun foo(/*0*/ x: L, S<*>>!>): L, S<*>>!>? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -41,7 +41,7 @@ public/*package*/ open class AnnotatedTypeArguments { public/*package*/ open inner class D2 : AnnotatedTypeArguments.C { public/*package*/ constructor D2() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: L, S<*>>!>!): L, S<*>>!> + @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable L, S<*>>!>!): @org.checkerframework.checker.nullness.qual.NonNull L, S<*>>!> public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.txt index bdbc02a09a8..3f6c9954188 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/methodWithTypeParameter.txt @@ -17,9 +17,9 @@ public/*package*/ open class Outer { public/*package*/ open inner class B : Outer.A { public/*package*/ constructor B() - @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: Y): X? + @java.lang.Override @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open override /*1*/ fun bar(/*0*/ @org.checkerframework.checker.nullness.qual.NonNull x: @org.checkerframework.checker.nullness.qual.NonNull Y<@org.checkerframework.checker.nullness.qual.NonNull R>): @org.checkerframework.checker.nullness.qual.Nullable X<@org.checkerframework.checker.nullness.qual.Nullable R!>? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: T1?): T2 + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable T1?): @org.checkerframework.checker.nullness.qual.NonNull T2 public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -35,9 +35,9 @@ public/*package*/ open class Outer { public/*package*/ open inner class D : Outer.C { public/*package*/ constructor D() - @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: Y!): X + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun bar(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable Y<@org.checkerframework.checker.nullness.qual.Nullable F!>!): @org.checkerframework.checker.nullness.qual.NonNull X<@org.checkerframework.checker.nullness.qual.NonNull F!> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: U?): W + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(/*0*/ @org.checkerframework.checker.nullness.qual.Nullable x: @org.checkerframework.checker.nullness.qual.Nullable U?): @org.checkerframework.checker.nullness.qual.NonNull W public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.txt index c93a978cf0a..fcd3a73fa92 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeDifferentConstructor.txt @@ -9,7 +9,7 @@ public/*package*/ open class Outer { public/*package*/ open inner class A { public/*package*/ constructor A() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): Base? + @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -25,7 +25,7 @@ public/*package*/ open class Outer { public/*package*/ open inner class C : Outer.A { public/*package*/ constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): Base + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Base public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -41,7 +41,7 @@ public/*package*/ open class Outer { public/*package*/ open inner class E : Outer.A { public/*package*/ constructor E() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): Derived + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -49,7 +49,7 @@ public/*package*/ open class Outer { public/*package*/ open inner class F : Outer.A { public/*package*/ constructor F() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): Derived + @java.lang.Override @org.checkerframework.checker.nullness.qual.NonNull public/*package*/ open override /*1*/ fun foo(): @org.checkerframework.checker.nullness.qual.NonNull Derived<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String!> public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.txt index ec51eaea470..eb9e30f2cc0 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/returnTypeOverrideInKotlin.txt @@ -6,7 +6,7 @@ public fun bar2(): Derived public open class A { public constructor A() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): Base? + @org.checkerframework.checker.nullness.qual.Nullable public/*package*/ open fun foo(): @org.checkerframework.checker.nullness.qual.Nullable Base<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>? public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.txt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.txt index 339e6b9a0c3..f9e9dcf1c1b 100644 --- a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.txt +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.txt @@ -3,7 +3,7 @@ package public/*package*/ open class A { public/*package*/ constructor A() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public/*package*/ open fun foo(): kotlin.collections.(Mutable)List! + public/*package*/ open fun foo(): kotlin.collections.(Mutable)List<@org.checkerframework.checker.nullness.qual.NonNull kotlin.String>! public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt index f6875fdff7e..5577e037321 100644 --- a/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt +++ b/compiler/tests-common/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -25,7 +25,6 @@ import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.jvm.compiler.ExpectedLoadErrorsUtil import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil -import org.jetbrains.kotlin.load.java.ANNOTATIONS_COPIED_TO_TYPES import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor import org.jetbrains.kotlin.load.java.structure.reflect.classId import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader @@ -55,9 +54,9 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { companion object { private val renderer = DescriptorRenderer.withOptions { withDefinedIn = false - excludedAnnotationClasses = (listOf( + excludedAnnotationClasses = setOf( FqName(ExpectedLoadErrorsUtil.ANNOTATION_CLASS_NAME) - ) + ANNOTATIONS_COPIED_TO_TYPES).toSet() + ) overrideRenderingPolicy = OverrideRenderingPolicy.RENDER_OPEN_OVERRIDE parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE includePropertyConstant = false diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt index 14bd8a16c06..d449c8be01e 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt @@ -18,10 +18,7 @@ package org.jetbrains.kotlin.load.java import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor -import org.jetbrains.kotlin.descriptors.resolveClassByFqName -import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass import org.jetbrains.kotlin.storage.StorageManager @@ -52,16 +49,6 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager) { return resolveTypeQualifierNickname(annotationClass) } - - fun isTypeQualifier(moduleDescriptor: ModuleDescriptor, classFqName: FqName): Boolean { - val classDescriptor = moduleDescriptor.resolveClassByFqName( - classFqName, NoLookupLocation.FROM_JAVA_LOADER - ) ?: return false - - if (classDescriptor.isTypeQualifierAnnotation) return true - - return resolveTypeQualifierNickname(classDescriptor) != null - } } private val ClassDescriptor.isAnnotatedWithTypeQualifier: Boolean diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.kt index c536e7c3826..30c18d35c6a 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.kt @@ -52,10 +52,3 @@ val READ_ONLY_ANNOTATIONS = listOf( val MUTABLE_ANNOTATIONS = listOf( JvmAnnotationNames.JETBRAINS_MUTABLE_ANNOTATION ) - -// When these annotations appear on a declaration, they are copied to the _type_ of the declaration, becoming type annotations -// See also DescriptorRendererOptions#excludedTypeAnnotationClasses -val ANNOTATIONS_COPIED_TO_TYPES: Set = listOf( - NULLABLE_ANNOTATIONS, NOT_NULL_ANNOTATIONS, READ_ONLY_ANNOTATIONS, MUTABLE_ANNOTATIONS, - listOf(JAVAX_NONNULL_ANNOTATION) -).flatMap { it }.toSet() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt index 97cc55a0b13..b6c010ce9e9 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt @@ -145,10 +145,8 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS protected fun computeMethodReturnType(method: JavaMethod, annotations: Annotations, c: LazyJavaResolverContext): KotlinType { val annotationMethod = method.containingClass.isAnnotationType val returnTypeAttrs = LazyJavaTypeAttributes( - TypeUsage.COMMON, annotations, - isForAnnotationParameter = annotationMethod, - moduleDescriptor = c.module, - annotationTypeQualifierResolver = c.components.annotationTypeQualifierResolver + TypeUsage.COMMON, + isForAnnotationParameter = annotationMethod ) return c.typeResolver.transformJavaType(method.returnType, returnTypeAttrs) } @@ -167,9 +165,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS val annotations = c.resolveAnnotations(javaParameter) val typeUsage = LazyJavaTypeAttributes( - TypeUsage.COMMON, annotations, - annotationTypeQualifierResolver = c.components.annotationTypeQualifierResolver, - moduleDescriptor = c.module + TypeUsage.COMMON ) val (outType, varargElementType) = if (javaParameter.isVararg) { @@ -289,9 +285,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS val propertyType = c.typeResolver.transformJavaType( field.type, LazyJavaTypeAttributes( - TypeUsage.COMMON, annotations, - annotationTypeQualifierResolver = c.components.annotationTypeQualifierResolver, - moduleDescriptor = c.module + TypeUsage.COMMON ) ) if (!isNotNullable) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt index ecf0cafe810..eabdaa7f412 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt @@ -17,13 +17,7 @@ package org.jetbrains.kotlin.load.java.lazy.types import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor -import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations -import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations -import org.jetbrains.kotlin.load.java.ANNOTATIONS_COPIED_TO_TYPES -import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver import org.jetbrains.kotlin.load.java.components.TypeUsage import org.jetbrains.kotlin.load.java.components.TypeUsage.COMMON import org.jetbrains.kotlin.load.java.components.TypeUsage.SUPERTYPE @@ -64,29 +58,27 @@ class JavaTypeResolver( } fun transformArrayType(arrayType: JavaArrayType, attr: JavaTypeAttributes, isVararg: Boolean = false): KotlinType { - return run { - val javaComponentType = arrayType.componentType - val primitiveType = (javaComponentType as? JavaPrimitiveType)?.type - if (primitiveType != null) { - val jetType = c.module.builtIns.getPrimitiveArrayKotlinType(primitiveType) - return@run if (attr.isForAnnotationParameter) - jetType - else KotlinTypeFactory.flexibleType(jetType, jetType.makeNullableAsSpecified(true)) - } + val javaComponentType = arrayType.componentType + val primitiveType = (javaComponentType as? JavaPrimitiveType)?.type + if (primitiveType != null) { + val jetType = c.module.builtIns.getPrimitiveArrayKotlinType(primitiveType) + return if (attr.isForAnnotationParameter) + jetType + else KotlinTypeFactory.flexibleType(jetType, jetType.makeNullableAsSpecified(true)) + } - val componentType = transformJavaType(javaComponentType, - COMMON.toAttributes(attr.isForAnnotationParameter)) + val componentType = transformJavaType(javaComponentType, + COMMON.toAttributes(attr.isForAnnotationParameter)) - if (attr.isForAnnotationParameter) { - val projectionKind = if (isVararg) OUT_VARIANCE else INVARIANT - return@run c.module.builtIns.getArrayType(projectionKind, componentType) - } + if (attr.isForAnnotationParameter) { + val projectionKind = if (isVararg) OUT_VARIANCE else INVARIANT + return c.module.builtIns.getArrayType(projectionKind, componentType) + } - KotlinTypeFactory.flexibleType( - c.module.builtIns.getArrayType(INVARIANT, componentType), - c.module.builtIns.getArrayType(OUT_VARIANCE, componentType).makeNullableAsSpecified(true) - ) - }.replaceAnnotations(attr.typeAnnotations) + return KotlinTypeFactory.flexibleType( + c.module.builtIns.getArrayType(INVARIANT, componentType), + c.module.builtIns.getArrayType(OUT_VARIANCE, componentType).makeNullableAsSpecified(true) + ) } private fun transformJavaClassifierType(javaType: JavaClassifierType, attr: JavaTypeAttributes): KotlinType { @@ -113,7 +105,7 @@ class JavaTypeResolver( } private fun computeSimpleJavaClassifierType(javaType: JavaClassifierType, attr: JavaTypeAttributes): SimpleType? { - val annotations = CompositeAnnotations(listOf(LazyJavaAnnotations(c, javaType), attr.typeAnnotations)) + val annotations = LazyJavaAnnotations(c, javaType) val constructor = computeTypeConstructor(javaType, attr) ?: return null val arguments = computeArguments(javaType, attr, constructor) val isNullable = attr.isNullable() @@ -294,7 +286,6 @@ interface JavaTypeAttributes { val howThisTypeIsUsed: TypeUsage val flexibility: JavaTypeFlexibility get() = INFLEXIBLE - val typeAnnotations: Annotations val isForAnnotationParameter: Boolean get() = false // Current type is upper bound of this type parameter @@ -310,15 +301,8 @@ enum class JavaTypeFlexibility { class LazyJavaTypeAttributes( override val howThisTypeIsUsed: TypeUsage, - annotations: Annotations, - override val isForAnnotationParameter: Boolean = false, - private val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver, - private val moduleDescriptor: ModuleDescriptor -): JavaTypeAttributes { - override val typeAnnotations = FilteredAnnotations(annotations) { - it in ANNOTATIONS_COPIED_TO_TYPES || annotationTypeQualifierResolver.isTypeQualifier(moduleDescriptor, it) - } -} + override val isForAnnotationParameter: Boolean = false +): JavaTypeAttributes fun TypeUsage.toAttributes( isForAnnotationParameter: Boolean = false, @@ -326,8 +310,6 @@ fun TypeUsage.toAttributes( ) = object : JavaTypeAttributes { override val howThisTypeIsUsed: TypeUsage = this@toAttributes - override val typeAnnotations: Annotations = Annotations.EMPTY - override val isForAnnotationParameter: Boolean = isForAnnotationParameter override val upperBoundOfTypeParameter: TypeParameterDescriptor? = upperBoundForTypeParameter } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index ec9e0d1802e..fd9b3884d92 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -18,7 +18,9 @@ package org.jetbrains.kotlin.load.java.typeEnhancement import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.annotations.Annotated import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.descriptors.annotations.composeAnnotations import org.jetbrains.kotlin.load.java.* import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor @@ -54,7 +56,7 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati val receiverTypeEnhancement = if (extensionReceiverParameter != null) - parts(isCovariant = false) { it.extensionReceiverParameter!!.type }.enhance() + parts(typeContainer = null, isCovariant = false) { it.extensionReceiverParameter!!.type }.enhance() else null @@ -72,11 +74,12 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati val valueParameterEnhancements = valueParameters.map { p -> - parts(isCovariant = false) { it.valueParameters[p.index].type } + parts(typeContainer = p, isCovariant = false) { it.valueParameters[p.index].type } .enhance(predefinedEnhancementInfo?.parametersInfo?.getOrNull(p.index)) } - val returnTypeEnhancement = parts(isCovariant = true) { it.returnType!! }.enhance(predefinedEnhancementInfo?.returnTypeInfo) + val returnTypeEnhancement = + parts(typeContainer = this, isCovariant = true) { it.returnType!! }.enhance(predefinedEnhancementInfo?.returnTypeInfo) if ((receiverTypeEnhancement?.wereChanges ?: false) || returnTypeEnhancement.wereChanges || valueParameterEnhancements.any { it.wereChanges }) { @@ -88,6 +91,7 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati } private inner class SignatureParts( + private val typeContainer: Annotated?, private val fromOverride: KotlinType, private val fromOverridden: Collection, private val isCovariant: Boolean @@ -129,12 +133,19 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati isNotNullTypeParameter = unwrap() is NotNullTypeParameter) } - private fun KotlinType.extractQualifiersFromAnnotations(): JavaTypeQualifiers { - fun List.ifPresent(qualifier: T) = if (any { annotations.findAnnotation(it) != null}) qualifier else null + private fun KotlinType.extractQualifiersFromAnnotations(isHeadTypeConstructor: Boolean): JavaTypeQualifiers { + val composedAnnotation = + if (isHeadTypeConstructor && typeContainer != null) + composeAnnotations(typeContainer.annotations, annotations) + else + annotations + + fun List.ifPresent(qualifier: T) = + if (any { composedAnnotation.findAnnotation(it) != null }) qualifier else null fun uniqueNotNull(x: T?, y: T?) = if (x == null || y == null || x == y) x ?: y else null - val nullability = annotations.extractNullability() + val nullability = composedAnnotation.extractNullability() return JavaTypeQualifiers( nullability, @@ -213,17 +224,20 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati val verticalSlice = indexedFromSupertypes.mapNotNull { it.getOrNull(index) } // Only the head type constructor is safely co-variant - qualifiers.computeQualifiersForOverride(verticalSlice, isCovariant && isHeadTypeConstructor) + qualifiers.computeQualifiersForOverride(verticalSlice, isCovariant && isHeadTypeConstructor, isHeadTypeConstructor) } return { index -> computedResult.getOrElse(index) { JavaTypeQualifiers.NONE } } } - private fun KotlinType.computeQualifiersForOverride(fromSupertypes: Collection, isCovariant: Boolean): JavaTypeQualifiers { + private fun KotlinType.computeQualifiersForOverride( + fromSupertypes: Collection, isCovariant: Boolean, + isHeadTypeConstructor: Boolean + ): JavaTypeQualifiers { val nullabilityFromSupertypes = fromSupertypes.mapNotNull { it.extractQualifiers().nullability }.toSet() val mutabilityFromSupertypes = fromSupertypes.mapNotNull { it.extractQualifiers().mutability }.toSet() - val own = extractQualifiersFromAnnotations() + val own = extractQualifiersFromAnnotations(isHeadTypeConstructor) val isAnyNonNullTypeParameter = own.isNotNullTypeParameter || fromSupertypes.any { it.extractQualifiers().isNotNullTypeParameter } @@ -268,8 +282,13 @@ class SignatureEnhancement(private val annotationTypeQualifierResolver: Annotati private data class PartEnhancementResult(val type: KotlinType, val wereChanges: Boolean) - private fun D.parts(isCovariant: Boolean, collector: (D) -> KotlinType): SignatureParts { + private fun D.parts( + typeContainer: Annotated?, + isCovariant: Boolean, + collector: (D) -> KotlinType + ): SignatureParts { return SignatureParts( + typeContainer, collector(this), this.overriddenDescriptors.map { @Suppress("UNCHECKED_CAST") diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt index 245cd34d131..f6ce55e7a1b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt @@ -219,31 +219,6 @@ interface DescriptorRendererOptions { } object ExcludedTypeAnnotations { - val annotationsForNullabilityAndMutability = setOf( - FqName("org.jetbrains.annotations.ReadOnly"), - FqName("org.jetbrains.annotations.Mutable"), - FqName("org.jetbrains.annotations.NotNull"), - FqName("org.jetbrains.annotations.Nullable"), - FqName("android.support.annotation.Nullable"), - FqName("android.support.annotation.NonNull"), - FqName("com.android.annotations.Nullable"), - FqName("com.android.annotations.NonNull"), - FqName("org.eclipse.jdt.annotation.Nullable"), - FqName("org.eclipse.jdt.annotation.NonNull"), - FqName("org.checkerframework.checker.nullness.qual.Nullable"), - FqName("org.checkerframework.checker.nullness.qual.NonNull"), - FqName("javax.annotation.Nonnull"), - FqName("javax.annotation.Nullable"), - FqName("javax.annotation.CheckForNull"), - FqName("edu.umd.cs.findbugs.annotations.NonNull"), - FqName("edu.umd.cs.findbugs.annotations.CheckForNull"), - FqName("edu.umd.cs.findbugs.annotations.Nullable"), - FqName("edu.umd.cs.findbugs.annotations.PossiblyNull"), - FqName("lombok.NonNull"), - FqName("io.reactivex.annotations.Nullable"), - FqName("io.reactivex.annotations.NonNull") - ) - val internalAnnotationsForResolve = setOf( FqName("kotlin.internal.NoInfer"), FqName("kotlin.internal.Exact") diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt index 8dcc4241903..c0337a70582 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererOptionsImpl.kt @@ -96,9 +96,7 @@ internal class DescriptorRendererOptionsImpl : DescriptorRendererOptions { override var excludedAnnotationClasses by property(emptySet()) - override var excludedTypeAnnotationClasses by property( - ExcludedTypeAnnotations.annotationsForNullabilityAndMutability - + ExcludedTypeAnnotations.internalAnnotationsForResolve) + override var excludedTypeAnnotationClasses by property(ExcludedTypeAnnotations.internalAnnotationsForResolve) override var annotationArgumentsRenderingPolicy by property(AnnotationArgumentsRenderingPolicy.NO_ARGUMENTS) @@ -111,4 +109,4 @@ internal class DescriptorRendererOptionsImpl : DescriptorRendererOptions { override var includeAdditionalModifiers: Boolean by property(true) override var parameterNamesInFunctionalTypes: Boolean by property(true) -} \ No newline at end of file +} diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt index 25844f3b671..6a23ca56f2c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt @@ -22,7 +22,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.isBuiltinFunctionClass import org.jetbrains.kotlin.lexer.KtModifierKeywordToken import org.jetbrains.kotlin.lexer.KtTokens -import org.jetbrains.kotlin.load.java.ANNOTATIONS_COPIED_TO_TYPES import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -42,7 +41,7 @@ import org.jetbrains.kotlin.serialization.js.DynamicTypeDeserializer import java.util.* // TODO: see DescriptorRendererOptions.excludedTypeAnnotationClasses for decompiler -private val ANNOTATIONS_NOT_LOADED_FOR_TYPES = (ANNOTATIONS_COPIED_TO_TYPES + KotlinBuiltIns.FQ_NAMES.parameterName).toSet() +private val ANNOTATIONS_NOT_LOADED_FOR_TYPES = setOf(KotlinBuiltIns.FQ_NAMES.parameterName) class TypeClsStubBuilder(private val c: ClsStubBuilderContext) { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/buildDecompiledText.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/buildDecompiledText.kt index 0d48d132365..b7926d11335 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/buildDecompiledText.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/buildDecompiledText.kt @@ -23,7 +23,6 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.renderer.DescriptorRendererModifier import org.jetbrains.kotlin.renderer.DescriptorRendererOptions -import org.jetbrains.kotlin.renderer.ExcludedTypeAnnotations import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver import org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry import org.jetbrains.kotlin.resolve.descriptorUtil.secondaryConstructors @@ -38,7 +37,7 @@ fun DescriptorRendererOptions.defaultDecompilerRendererOptions() { classWithPrimaryConstructor = true secondaryConstructorsAsPrimary = false modifiers = DescriptorRendererModifier.ALL - excludedTypeAnnotationClasses = ExcludedTypeAnnotations.annotationsForNullabilityAndMutability + excludedTypeAnnotationClasses = emptySet() alwaysRenderModifiers = true parameterNamesInFunctionalTypes = false // to support parameters names in decompiled text we need to load annotation arguments }