From 57b7b914444097824cfdcc50ebc425fefcaa12a2 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Fri, 16 Jun 2017 14:50:13 +0300 Subject: [PATCH] Do not add container annotaions to type artificially It was only used for type-related nullability/mutability annotations and it was necessary to remove them in the descriptor renderer (duplicating their fqnames there). At the same time they're only needed for types enhancement where they can be simply restored from type owners' descriptors The testData changes are more or less correct: this kind of annotations is bound both to types themselves and their use because of their targets --- .../tests/jsr305NullabilityNicknames.txt | 6 +- .../tests/checkerFramework.txt | 8 +-- .../foreignAnnotationsJava8/tests/eclipse.txt | 8 +-- .../annotatedTypeArguments.txt | 6 +- .../methodWithTypeParameter.txt | 8 +-- .../returnTypeDifferentConstructor.txt | 8 +-- .../returnTypeOverrideInKotlin.txt | 2 +- .../tests/typeEnhancement/simple.txt | 2 +- .../AbstractJvmRuntimeDescriptorLoaderTest.kt | 5 +- .../java/AnnotationTypeQualifierResolver.kt | 13 ---- .../kotlin/load/java/JvmAnnotationNames.kt | 7 --- .../java/lazy/descriptors/LazyJavaScope.kt | 14 ++--- .../load/java/lazy/types/JavaTypeResolver.kt | 60 +++++++------------ .../typeEnhancement/signatureEnhancement.kt | 39 ++++++++---- .../kotlin/renderer/DescriptorRenderer.kt | 25 -------- .../renderer/DescriptorRendererOptionsImpl.kt | 6 +- .../stubBuilder/TypeClsStubBuilder.kt | 3 +- .../textBuilder/buildDecompiledText.kt | 3 +- 18 files changed, 84 insertions(+), 139 deletions(-) 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 }