diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java index 0c6bdae906e..b8a50b0e375 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java @@ -19,7 +19,6 @@ package org.jetbrains.kotlin.codegen; import kotlin.collections.CollectionsKt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.codegen.annotation.WrappedAnnotated; import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper; import org.jetbrains.kotlin.config.JvmTarget; import org.jetbrains.kotlin.descriptors.*; @@ -156,36 +155,47 @@ public abstract class AnnotationCodegen { @Nullable Type returnType, @NotNull Set annotationDescriptorsAlreadyPresent ) { - Annotated unwrapped = annotated; - if (annotated instanceof WrappedAnnotated) { - unwrapped = ((WrappedAnnotated) annotated).getOriginalAnnotated(); + if (annotated instanceof CallableDescriptor) { + generateAdditionalCallableAnnotations((CallableDescriptor) annotated, returnType, annotationDescriptorsAlreadyPresent); + } + else if (annotated instanceof FieldDescriptor) { + generateAdditionalCallableAnnotations( + ((FieldDescriptor) annotated).getCorrespondingProperty(), returnType, annotationDescriptorsAlreadyPresent + ); + } + else if (annotated instanceof ClassDescriptor) { + generateAdditionalClassAnnotations(annotationDescriptorsAlreadyPresent, (ClassDescriptor) annotated); + } + } + + private void generateAdditionalCallableAnnotations( + @NotNull CallableDescriptor descriptor, + @Nullable Type returnType, + @NotNull Set annotationDescriptorsAlreadyPresent + ) { + // No need to annotate privates, synthetic accessors and their parameters + if (isInvisibleFromTheOutside(descriptor)) return; + if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return; + + // No need to annotate annotation methods since they're always non-null + if (descriptor instanceof PropertyGetterDescriptor && + DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration())) { + return; } - if (unwrapped instanceof CallableDescriptor) { - CallableDescriptor descriptor = (CallableDescriptor) unwrapped; - - // No need to annotate privates, synthetic accessors and their parameters - if (isInvisibleFromTheOutside(descriptor)) return; - if (descriptor instanceof ValueParameterDescriptor && isInvisibleFromTheOutside(descriptor.getContainingDeclaration())) return; - - // No need to annotate annotation methods since they're always non-null - if (descriptor instanceof PropertyGetterDescriptor && - DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration())) { - return; - } - - if (returnType != null && !AsmUtil.isPrimitive(returnType)) { - generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent); - } + if (returnType != null && !AsmUtil.isPrimitive(returnType)) { + generateNullabilityAnnotation(descriptor.getReturnType(), annotationDescriptorsAlreadyPresent); } + } - if (unwrapped instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) unwrapped; - if (classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) { - generateDocumentedAnnotation(classDescriptor, annotationDescriptorsAlreadyPresent); - generateRetentionAnnotation(classDescriptor, annotationDescriptorsAlreadyPresent); - generateTargetAnnotation(classDescriptor, annotationDescriptorsAlreadyPresent); - } + private void generateAdditionalClassAnnotations( + @NotNull Set annotationDescriptorsAlreadyPresent, + @NotNull ClassDescriptor descriptor + ) { + if (descriptor.getKind() == ClassKind.ANNOTATION_CLASS) { + generateDocumentedAnnotation(descriptor, annotationDescriptorsAlreadyPresent); + generateRetentionAnnotation(descriptor, annotationDescriptorsAlreadyPresent); + generateTargetAnnotation(descriptor, annotationDescriptorsAlreadyPresent); } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java index f7081d1154a..1c89f72f2e2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java @@ -348,14 +348,6 @@ public class JvmCodegenUtil { !JvmAbi.isMappedIntrinsicCompanionObject((ClassDescriptor) companionObject); } - public static boolean hasBackingField( - @NotNull PropertyDescriptor descriptor, @NotNull OwnerKind kind, @NotNull BindingContext bindingContext - ) { - return !isJvmInterface(descriptor.getContainingDeclaration()) && - kind != OwnerKind.DEFAULT_IMPLS && - !Boolean.FALSE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor)); - } - public static boolean isDeclarationOfBigArityFunctionInvoke(@Nullable DeclarationDescriptor descriptor) { return descriptor instanceof FunctionInvokeDescriptor && ((FunctionInvokeDescriptor) descriptor).hasBigArity(); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java index be32306631d..cdccb4d7da1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java @@ -10,7 +10,6 @@ import com.intellij.psi.PsiElement; import kotlin.collections.CollectionsKt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.codegen.annotation.AnnotatedWithFakeAnnotations; import org.jetbrains.kotlin.codegen.context.CodegenContextUtil; import org.jetbrains.kotlin.codegen.context.FieldOwnerContext; import org.jetbrains.kotlin.codegen.context.MultifileClassFacadeContext; @@ -19,8 +18,6 @@ import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper; import org.jetbrains.kotlin.config.LanguageFeature; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.Annotated; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationSplitter; import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.fileClasses.JvmFileClassUtilKt; @@ -36,7 +33,6 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKt; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodGenericSignature; import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature; import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedPropertyDescriptor; -import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.types.ErrorUtils; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.org.objectweb.asm.FieldVisitor; @@ -129,7 +125,7 @@ public class PropertyCodegen { kind == OwnerKind.DEFAULT_IMPLS || kind == OwnerKind.ERASED_INLINE_CLASS : "Generating property with a wrong kind (" + kind + "): " + descriptor; - genBackingFieldAndAnnotations(declaration, descriptor, false); + genBackingFieldAndAnnotations(declaration, descriptor); boolean isDefaultGetterAndSetter = isDefaultAccessor(getter) && isDefaultAccessor(setter); @@ -154,34 +150,21 @@ public class PropertyCodegen { if (UnderscoreUtilKt.isSingleUnderscore(entry)) return; - genBackingFieldAndAnnotations(entry, descriptor, false); + genBackingFieldAndAnnotations(entry, descriptor); generateGetter(entry, descriptor, null); generateSetter(entry, descriptor, null); } - private void genBackingFieldAndAnnotations( - @Nullable KtNamedDeclaration declaration, @NotNull PropertyDescriptor descriptor, boolean isParameter - ) { - boolean hasBackingField = JvmCodegenUtil.hasBackingField(descriptor, kind, bindingContext); - boolean hasDelegate = declaration instanceof KtProperty && ((KtProperty) declaration).hasDelegate(); - - AnnotationSplitter annotationSplitter = - AnnotationSplitter.create(LockBasedStorageManager.NO_LOCKS, - descriptor.getAnnotations(), - AnnotationSplitter.getTargetSet(isParameter, descriptor.isVar(), hasBackingField, hasDelegate)); - - Annotations propertyAnnotations = annotationSplitter.getAnnotationsForTarget(AnnotationUseSiteTarget.PROPERTY); - + private void genBackingFieldAndAnnotations(@Nullable KtNamedDeclaration declaration, @NotNull PropertyDescriptor descriptor) { // Fields and '$annotations' methods for non-private const properties are generated in the multi-file facade boolean isBackingFieldOwner = descriptor.isConst() && !Visibilities.isPrivate(descriptor.getVisibility()) ? !(context instanceof MultifileClassPartContext) : CodegenContextUtil.isImplClassOwner(context); - Annotations fieldAnnotations = annotationSplitter.getAnnotationsForTarget(AnnotationUseSiteTarget.FIELD); - Annotations delegateAnnotations = annotationSplitter.getAnnotationsForTarget(AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD); + Annotations propertyAnnotations = descriptor.getAnnotations(); assert declaration != null : "Declaration is null: " + descriptor + " (context=" + context + ")"; - generateBackingField(declaration, descriptor, fieldAnnotations, delegateAnnotations, isBackingFieldOwner); + generateBackingField(declaration, descriptor, descriptor.getBackingField(), descriptor.getDelegateField(), isBackingFieldOwner); generateSyntheticMethodIfNeeded(descriptor, propertyAnnotations, isBackingFieldOwner); } @@ -250,12 +233,12 @@ public class PropertyCodegen { return !Visibilities.isPrivate(descriptor.getVisibility()); } - public void generatePrimaryConstructorProperty(@NotNull KtParameter p, @NotNull PropertyDescriptor descriptor) { - genBackingFieldAndAnnotations(p, descriptor, true); + public void generatePrimaryConstructorProperty(@NotNull KtParameter parameter, @NotNull PropertyDescriptor descriptor) { + genBackingFieldAndAnnotations(parameter, descriptor); if (areAccessorsNeededForPrimaryConstructorProperty(descriptor, context.getContextKind())) { - generateGetter(p, descriptor, null); - generateSetter(p, descriptor, null); + generateGetter(parameter, descriptor, null); + generateSetter(parameter, descriptor, null); } } @@ -321,8 +304,8 @@ public class PropertyCodegen { private void generateBackingField( @NotNull KtNamedDeclaration p, @NotNull PropertyDescriptor descriptor, - @NotNull Annotations backingFieldAnnotations, - @NotNull Annotations delegateAnnotations, + @Nullable FieldDescriptor backingField, + @Nullable FieldDescriptor delegateField, boolean isBackingFieldOwner ) { if (isJvmInterface(descriptor.getContainingDeclaration()) || kind == OwnerKind.DEFAULT_IMPLS || @@ -331,10 +314,10 @@ public class PropertyCodegen { } if (p instanceof KtProperty && ((KtProperty) p).hasDelegate()) { - generatePropertyDelegateAccess((KtProperty) p, descriptor, delegateAnnotations, isBackingFieldOwner); + generatePropertyDelegateAccess((KtProperty) p, descriptor, delegateField, isBackingFieldOwner); } else if (Boolean.TRUE.equals(bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor))) { - generateBackingFieldAccess(p, descriptor, backingFieldAnnotations, isBackingFieldOwner); + generateBackingFieldAccess(p, descriptor, backingField, isBackingFieldOwner); } } @@ -369,18 +352,18 @@ public class PropertyCodegen { } private void generateBackingField( - KtNamedDeclaration element, - PropertyDescriptor propertyDescriptor, + @NotNull KtNamedDeclaration element, + @NotNull PropertyDescriptor propertyDescriptor, boolean isDelegate, - KotlinType kotlinType, - Object defaultValue, - Annotations annotations, + @NotNull KotlinType kotlinType, + @Nullable Object defaultValue, + @Nullable FieldDescriptor annotatedField, boolean isBackingFieldOwner ) { int modifiers = getDeprecatedAccessFlag(propertyDescriptor); for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.FIELD_FLAGS) { - if (flagAnnotation.hasAnnotation(propertyDescriptor.getOriginal())) { + if (annotatedField != null && flagAnnotation.hasAnnotation(annotatedField)) { modifiers |= flagAnnotation.getJvmFlag(); } } @@ -428,21 +411,21 @@ public class PropertyCodegen { isDelegate ? null : typeMapper.mapFieldSignature(kotlinType, propertyDescriptor), defaultValue ); - Annotated fieldAnnotated = new AnnotatedWithFakeAnnotations(propertyDescriptor, annotations); - AnnotationCodegen.forField(fv, memberCodegen, typeMapper).genAnnotations( - fieldAnnotated, type, isDelegate ? AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD : AnnotationUseSiteTarget.FIELD); + if (annotatedField != null) { + AnnotationCodegen.forField(fv, memberCodegen, typeMapper).genAnnotations(annotatedField, type); + } } } private void generatePropertyDelegateAccess( @NotNull KtProperty p, @NotNull PropertyDescriptor propertyDescriptor, - @NotNull Annotations annotations, + @Nullable FieldDescriptor delegateField, boolean isBackingFieldOwner ) { KotlinType delegateType = getDelegateTypeForProperty(p, propertyDescriptor); - generateBackingField(p, propertyDescriptor, true, delegateType, null, annotations, isBackingFieldOwner); + generateBackingField(p, propertyDescriptor, true, delegateType, null, delegateField, isBackingFieldOwner); } @NotNull @@ -470,7 +453,7 @@ public class PropertyCodegen { private void generateBackingFieldAccess( @NotNull KtNamedDeclaration p, @NotNull PropertyDescriptor propertyDescriptor, - @NotNull Annotations annotations, + @Nullable FieldDescriptor backingField, boolean isBackingFieldOwner ) { Object value = null; @@ -482,7 +465,7 @@ public class PropertyCodegen { } } - generateBackingField(p, propertyDescriptor, false, propertyDescriptor.getType(), value, annotations, isBackingFieldOwner); + generateBackingField(p, propertyDescriptor, false, propertyDescriptor.getType(), value, backingField, isBackingFieldOwner); } private boolean shouldWriteFieldInitializer(@NotNull PropertyDescriptor descriptor) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/annotation/AnnotatedWithOnlyTargetedAnnotations.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/annotation/AnnotatedWithOnlyTargetedAnnotations.kt deleted file mode 100644 index daa327758c0..00000000000 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/annotation/AnnotatedWithOnlyTargetedAnnotations.kt +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright 2010-2016 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.codegen.annotation - -import org.jetbrains.kotlin.descriptors.annotations.Annotated -import org.jetbrains.kotlin.descriptors.annotations.Annotations - -interface WrappedAnnotated : Annotated { - val originalAnnotated: Annotated -} - -class AnnotatedWithFakeAnnotations(override val originalAnnotated: Annotated, override val annotations: Annotations) : WrappedAnnotated diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt index f48588ffe28..3baa8b3b973 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/annotations/jvmAnnotationUtil.kt @@ -7,6 +7,8 @@ package org.jetbrains.kotlin.resolve.jvm.annotations import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.annotations.Annotated import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.name.FqName @@ -29,7 +31,7 @@ fun DeclarationDescriptor.findJvmOverloadsAnnotation(): AnnotationDescriptor? = annotations.findAnnotation(JVM_OVERLOADS_FQ_NAME) fun DeclarationDescriptor.findJvmFieldAnnotation(): AnnotationDescriptor? = - DescriptorUtils.getAnnotationByFqName(annotations, JVM_FIELD_ANNOTATION_FQ_NAME) + (this as? PropertyDescriptor)?.backingField?.annotations?.findAnnotation(JVM_FIELD_ANNOTATION_FQ_NAME) fun DeclarationDescriptor.hasJvmFieldAnnotation(): Boolean = findJvmFieldAnnotation() != null @@ -40,8 +42,9 @@ fun DeclarationDescriptor.isCallableMemberWithJvmDefaultAnnotation(): Boolean = fun CallableMemberDescriptor.hasJvmDefaultAnnotation(): Boolean = DescriptorUtils.getDirectMember(this).annotations.hasAnnotation(JVM_DEFAULT_FQ_NAME) -fun DeclarationDescriptor.findJvmSyntheticAnnotation(): AnnotationDescriptor? = +private fun Annotated.findJvmSyntheticAnnotation(): AnnotationDescriptor? = DescriptorUtils.getAnnotationByFqName(annotations, JVM_SYNTHETIC_ANNOTATION_FQ_NAME) + ?: (this as? PropertyDescriptor)?.backingField?.annotations?.findAnnotation(JVM_SYNTHETIC_ANNOTATION_FQ_NAME) fun DeclarationDescriptor.hasJvmSyntheticAnnotation(): Boolean = findJvmSyntheticAnnotation() != null @@ -49,8 +52,5 @@ fun DeclarationDescriptor.hasJvmSyntheticAnnotation(): Boolean = fun DeclarationDescriptor.findStrictfpAnnotation(): AnnotationDescriptor? = DescriptorUtils.getAnnotationByFqName(annotations, STRICTFP_ANNOTATION_FQ_NAME) -fun DeclarationDescriptor.findVolatileAnnotation(): AnnotationDescriptor? = - DescriptorUtils.getAnnotationByFqName(annotations, VOLATILE_ANNOTATION_FQ_NAME) - fun DeclarationDescriptor.findSynchronizedAnnotation(): AnnotationDescriptor? = DescriptorUtils.getAnnotationByFqName(annotations, SYNCHRONIZED_ANNOTATION_FQ_NAME) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt index 1a409133046..66570d59243 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmFieldApplicabilityChecker.kt @@ -50,10 +50,13 @@ class JvmFieldApplicabilityChecker : DeclarationChecker { } override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - val annotation = descriptor.findJvmFieldAnnotation() ?: return + if (descriptor !is PropertyDescriptor) return + + val annotation = descriptor.findJvmFieldAnnotation() + ?: descriptor.delegateField?.annotations?.findAnnotation(JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME) + ?: return val problem = when { - descriptor !is PropertyDescriptor -> return declaration is KtProperty && declaration.hasDelegate() -> DELEGATE !descriptor.hasBackingField(context.trace.bindingContext) -> return descriptor.isOverridable -> NOT_FINAL diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSyntheticApplicabilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSyntheticApplicabilityChecker.kt index 5697c2e4226..0f1e90fdd89 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSyntheticApplicabilityChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmSyntheticApplicabilityChecker.kt @@ -17,19 +17,18 @@ package org.jetbrains.kotlin.resolve.jvm.checkers import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.VariableDescriptor +import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.psi.KtDeclaration -import org.jetbrains.kotlin.psi.KtProperty import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext -import org.jetbrains.kotlin.resolve.jvm.annotations.findJvmSyntheticAnnotation +import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_SYNTHETIC_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm class JvmSyntheticApplicabilityChecker : DeclarationChecker { override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - val annotation = descriptor.findJvmSyntheticAnnotation() ?: return - if (declaration is KtProperty && descriptor is VariableDescriptor && declaration.hasDelegate()) { + val annotation = (descriptor as? PropertyDescriptor)?.delegateField?.annotations?.findAnnotation(JVM_SYNTHETIC_ANNOTATION_FQ_NAME) + if (annotation != null) { val annotationEntry = DescriptorToSourceUtils.getSourceFromAnnotation(annotation) ?: return context.trace.report(ErrorsJvm.JVM_SYNTHETIC_ON_DELEGATE.on(annotationEntry)) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt index b0232cf8235..a5adc41087c 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt @@ -34,9 +34,9 @@ import org.jetbrains.kotlin.resolve.calls.components.isActualParameterWithCorres import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext import org.jetbrains.kotlin.resolve.inline.InlineUtil +import org.jetbrains.kotlin.resolve.jvm.annotations.VOLATILE_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.resolve.jvm.annotations.findJvmOverloadsAnnotation import org.jetbrains.kotlin.resolve.jvm.annotations.findSynchronizedAnnotation -import org.jetbrains.kotlin.resolve.jvm.annotations.findVolatileAnnotation import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmFieldAnnotation import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm @@ -156,16 +156,18 @@ class JvmNameAnnotationChecker : DeclarationChecker { class VolatileAnnotationChecker : DeclarationChecker { override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - val volatileAnnotation = descriptor.findVolatileAnnotation() - if (volatileAnnotation != null) { - if (descriptor is PropertyDescriptor && !descriptor.isVar) { - val annotationEntry = DescriptorToSourceUtils.getSourceFromAnnotation(volatileAnnotation) ?: return - context.trace.report(ErrorsJvm.VOLATILE_ON_VALUE.on(annotationEntry)) - } - if (declaration is KtProperty && declaration.hasDelegate()) { - val annotationEntry = DescriptorToSourceUtils.getSourceFromAnnotation(volatileAnnotation) ?: return - context.trace.report(ErrorsJvm.VOLATILE_ON_DELEGATE.on(annotationEntry)) - } + if (descriptor !is PropertyDescriptor) return + + val fieldAnnotation = descriptor.backingField?.annotations?.findAnnotation(VOLATILE_ANNOTATION_FQ_NAME) + if (fieldAnnotation != null && !descriptor.isVar) { + val annotationEntry = DescriptorToSourceUtils.getSourceFromAnnotation(fieldAnnotation) ?: return + context.trace.report(ErrorsJvm.VOLATILE_ON_VALUE.on(annotationEntry)) + } + + val delegateAnnotation = descriptor.delegateField?.annotations?.findAnnotation(VOLATILE_ANNOTATION_FQ_NAME) + if (delegateAnnotation != null) { + val annotationEntry = DescriptorToSourceUtils.getSourceFromAnnotation(delegateAnnotation) ?: return + context.trace.report(ErrorsJvm.VOLATILE_ON_DELEGATE.on(annotationEntry)) } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt index 09478676351..f86e014d5f9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt @@ -87,16 +87,15 @@ class AnnotationSplitter( class PropertyWrapper @JvmOverloads constructor(val declaration: KtDeclaration, var descriptor: PropertyDescriptor? = null) private val splitAnnotations = storageManager.createLazyValue { - val map = hashMapOf>() - val other = arrayListOf() + val map = hashMapOf>() + val other = arrayListOf() val applicableTargets = applicableTargetsLazy() val applicableTargetsWithoutUseSiteTarget = applicableTargets.intersect(TARGET_PRIORITIES) - outer@ for (annotationWithTarget in allAnnotations.getAllAnnotations()) { - val useSiteTarget = annotationWithTarget.target + outer@ for ((annotation, useSiteTarget) in allAnnotations.getAllAnnotations()) { if (useSiteTarget != null) { if (useSiteTarget in applicableTargets) - map.getOrPut(useSiteTarget, { arrayListOf() }).add(annotationWithTarget) + map.getOrPut(useSiteTarget) { arrayListOf() }.add(annotation) continue@outer } @@ -105,38 +104,36 @@ class AnnotationSplitter( if (target !in applicableTargetsWithoutUseSiteTarget) continue val declarationSiteTargetForCurrentTarget = KotlinTarget.USE_SITE_MAPPING[target] ?: continue - val applicableTargetsForAnnotation = AnnotationChecker.applicableTargetSet(annotationWithTarget.annotation) + val applicableTargetsForAnnotation = AnnotationChecker.applicableTargetSet(annotation) if (declarationSiteTargetForCurrentTarget in applicableTargetsForAnnotation) { - map.getOrPut(target, { arrayListOf() }).add(annotationWithTarget) + map.getOrPut(target) { arrayListOf() }.add(annotation) continue@outer } } - other.add(annotationWithTarget) + other.add(annotation) } - map to AnnotationsImpl.create(other) + + map to AnnotationsImpl(other) } fun getOtherAnnotations(): Annotations = LazySplitAnnotations(storageManager, null) fun getAnnotationsForTarget(target: AnnotationUseSiteTarget): Annotations = LazySplitAnnotations(storageManager, target) - fun getAnnotationsForTargets(vararg targets: AnnotationUseSiteTarget): Annotations { - return CompositeAnnotations(targets.map { getAnnotationsForTarget(it) }) - } - private inner class LazySplitAnnotations( storageManager: StorageManager, val target: AnnotationUseSiteTarget? ) : Annotations, LazyEntity { private val annotations by storageManager.createLazyValue { - val splitAnnotations = this@AnnotationSplitter.splitAnnotations() + val (targeted, other) = this@AnnotationSplitter.splitAnnotations() - if (target != null) - AnnotationsImpl.create(splitAnnotations.first[target] ?: emptyList()) - else - splitAnnotations.second + if (target != null) { + targeted[target]?.let(::AnnotationsImpl) ?: Annotations.EMPTY + } else { + other + } } override fun forceResolveAllContents() { @@ -151,5 +148,4 @@ class AnnotationSplitter( override fun iterator() = annotations.iterator() override fun toString() = annotations.toString() } - } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index d4062be18fd..4cf7e9ac1ef 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -876,8 +876,9 @@ public class DescriptorResolver { () -> AnnotationSplitter.getTargetSet(false, trace.getBindingContext(), wrapper)); Annotations propertyAnnotations = new CompositeAnnotations(CollectionsKt.listOf( - annotationSplitter.getAnnotationsForTargets(PROPERTY, FIELD, PROPERTY_DELEGATE_FIELD), - annotationSplitter.getOtherAnnotations())); + annotationSplitter.getAnnotationsForTarget(PROPERTY), + annotationSplitter.getOtherAnnotations()) + ); PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create( container, @@ -984,7 +985,11 @@ public class DescriptorResolver { propertyInfo.getPropertySetter(), propertyInfo.getHasDelegate()); - propertyDescriptor.initialize(getter, setter); + propertyDescriptor.initialize( + getter, setter, + new FieldDescriptorImpl(annotationSplitter.getAnnotationsForTarget(FIELD), propertyDescriptor), + new FieldDescriptorImpl(annotationSplitter.getAnnotationsForTarget(PROPERTY_DELEGATE_FIELD), propertyDescriptor) + ); trace.record(BindingContext.VARIABLE, variableDeclaration, propertyDescriptor); return propertyDescriptor; @@ -1222,8 +1227,9 @@ public class DescriptorResolver { () -> AnnotationSplitter.getTargetSet(true, trace.getBindingContext(), propertyWrapper)); Annotations propertyAnnotations = new CompositeAnnotations( - annotationSplitter.getAnnotationsForTargets(PROPERTY, FIELD), - annotationSplitter.getOtherAnnotations()); + annotationSplitter.getAnnotationsForTarget(PROPERTY), + annotationSplitter.getOtherAnnotations() + ); PropertyDescriptorImpl propertyDescriptor = PropertyDescriptorImpl.create( classDescriptor, @@ -1256,7 +1262,12 @@ public class DescriptorResolver { ) : null; - propertyDescriptor.initialize(getter, setter); + propertyDescriptor.initialize( + getter, setter, + new FieldDescriptorImpl(annotationSplitter.getAnnotationsForTarget(FIELD), propertyDescriptor), + null + ); + getter.initialize(propertyDescriptor.getType()); trace.record(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter, propertyDescriptor); diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt index 135dc5add92..c821d3ac711 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt @@ -578,4 +578,12 @@ open class WrappedPropertyDescriptor( } override val isDelegated get() = false -} \ No newline at end of file + + override fun getBackingField(): FieldDescriptor? { + TODO("not implemented") + } + + override fun getDelegateField(): FieldDescriptor? { + TODO("not implemented") + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/DeepCopyIrTreeWithDescriptors.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/DeepCopyIrTreeWithDescriptors.kt index b069d12e1e1..4edb9c0f587 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/DeepCopyIrTreeWithDescriptors.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/inline/DeepCopyIrTreeWithDescriptors.kt @@ -366,7 +366,9 @@ internal class DeepCopyIrTreeWithDescriptors(val targetDescriptor: FunctionDescr initialize( /* getter = */ oldDescriptor.getter?.let { copyPropertyGetterDescriptor(it, this) }, - /* setter = */ oldDescriptor.setter?.let { copyPropertySetterDescriptor(it, this) }) + /* setter = */ oldDescriptor.setter?.let { copyPropertySetterDescriptor(it, this) }, + oldDescriptor.backingField, oldDescriptor.delegateField + ) overriddenDescriptors += oldDescriptor.overriddenDescriptors } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/Util.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/Util.kt index b727213b896..c76d19dcb96 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/Util.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/Util.kt @@ -18,11 +18,12 @@ package org.jetbrains.kotlin.backend.jvm.descriptors import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.impl.* +import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl +import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl +import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl +import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.KotlinType -import org.jetbrains.kotlin.types.TypeProjectionImpl -import org.jetbrains.kotlin.types.TypeSubstitutor fun PropertyDescriptorImpl.initialize( type: KotlinType, @@ -30,10 +31,12 @@ fun PropertyDescriptorImpl.initialize( dispatchReceiverParameter: ReceiverParameterDescriptor? = null, extensionReceiverParameter: ReceiverParameterDescriptor? = null, getter: PropertyGetterDescriptorImpl? = null, - setter: PropertySetterDescriptorImpl? = null + setter: PropertySetterDescriptorImpl? = null, + backingField: FieldDescriptor? = null, + delegateField: FieldDescriptor? = null ): PropertyDescriptorImpl { setType(type, typeParameters, dispatchReceiverParameter, extensionReceiverParameter) - initialize(getter, setter) + initialize(getter, setter, backingField, delegateField) return this } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnnotationGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnnotationGenerator.kt index 4e0701ce695..4d895f32adb 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnnotationGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/AnnotationGenerator.kt @@ -5,9 +5,11 @@ package org.jetbrains.kotlin.psi2ir.generators -import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.ir.IrElement -import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrDeclaration +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin +import org.jetbrains.kotlin.ir.declarations.IrField +import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid @@ -31,27 +33,15 @@ class AnnotationGenerator(context: GeneratorContext) : IrElementVisitorVoid { } private fun generateAnnotationsForDeclaration(declaration: IrDeclaration) { - declaration.descriptor.annotations.getAllAnnotations() - .filter { isAnnotationTargetMatchingDeclaration(it.target, declaration) } - .mapTo(declaration.annotations) { - constantValueGenerator.generateAnnotationConstructorCall(it.annotation) - } - } + // Delegate field is mapped to a new property descriptor with annotations of the original property delegate + // (see IrPropertyDelegateDescriptorImpl), but annotations on backing fields should be processed manually here + val annotatedDescriptor = + if (declaration is IrField && declaration.origin != IrDeclarationOrigin.DELEGATE) + declaration.descriptor.backingField + else declaration.descriptor - private fun isAnnotationTargetMatchingDeclaration(target: AnnotationUseSiteTarget?, element: IrElement): Boolean = - when (element) { - is IrProperty -> - target == null || target == AnnotationUseSiteTarget.PROPERTY - - is IrField -> - target == AnnotationUseSiteTarget.FIELD || target == AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD - - is IrSimpleFunction -> - target == null || target == AnnotationUseSiteTarget.PROPERTY_GETTER || target == AnnotationUseSiteTarget.PROPERTY_SETTER - - is IrValueParameter -> - target == null || target == AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER - - else -> target == null + annotatedDescriptor?.annotations?.mapTo(declaration.annotations) { + constantValueGenerator.generateAnnotationConstructorCall(it) } + } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt index b670bc147a4..84b90b14efa 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDelegateDescriptor.kt @@ -97,7 +97,7 @@ class IrPropertyDelegateDescriptorImpl( correspondingProperty.containingDeclaration, getDelegateName(correspondingProperty.name), delegateType, - correspondingProperty.annotations + correspondingProperty.delegateField?.annotations ?: Annotations.EMPTY ), IrPropertyDelegateDescriptor diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt index 495d141421d..bf5a367ffda 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/elements/KtLightModifierList.kt @@ -27,13 +27,9 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor -import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget -import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget -import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getParentOfType import org.jetbrains.kotlin.psi.psiUtil.isPropertyParameter -import org.jetbrains.kotlin.resolve.AnnotationChecker import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_DEFAULT_FQ_NAME import org.jetbrains.kotlin.resolve.source.getPsi @@ -146,25 +142,26 @@ private fun getAnnotationDescriptors(declaration: KtDeclaration, annotatedLightE } val annotatedDescriptor = when { - descriptor is ClassDescriptor && annotatedLightElement is KtLightMethod && annotatedLightElement.isConstructor -> descriptor.unsubstitutedPrimaryConstructor - descriptor !is PropertyDescriptor || annotatedLightElement !is KtLightMethod -> descriptor + descriptor is ClassDescriptor && annotatedLightElement is KtLightMethod && annotatedLightElement.isConstructor -> + descriptor.unsubstitutedPrimaryConstructor + descriptor !is PropertyDescriptor -> descriptor + annotatedLightElement is KtLightFieldImpl.KtLightFieldForDeclaration -> descriptor.backingField + annotatedLightElement !is KtLightMethod -> descriptor annotatedLightElement.isGetter -> descriptor.getter annotatedLightElement.isSetter -> descriptor.setter else -> descriptor } ?: return emptyList() - val annotations = annotatedDescriptor.annotations.getAllAnnotations() - .filter { it.matches(annotatedLightElement) } - .map { it.annotation } + val annotations = annotatedDescriptor.annotations.toMutableList() if (descriptor is PropertyDescriptor) { val jvmDefault = descriptor.annotations.findAnnotation(JVM_DEFAULT_FQ_NAME) if (jvmDefault != null) { - return annotations + jvmDefault + annotations.add(jvmDefault) } } - return annotations + return annotations } private fun hasAnnotationsInSource(declaration: KtDeclaration): Boolean { @@ -178,19 +175,3 @@ private fun hasAnnotationsInSource(declaration: KtDeclaration): Boolean { return false } - -private fun AnnotationWithTarget.matches(annotated: KtLightElement<*, *>): Boolean { - if (annotated is KtLightFieldImpl.KtLightFieldForDeclaration) { - if (target == AnnotationUseSiteTarget.FIELD) return true - - if (target != null) return false - - val declarationSiteTargets = AnnotationChecker.applicableTargetSet(annotation) - return KotlinTarget.FIELD in declarationSiteTargets && KotlinTarget.PROPERTY !in declarationSiteTargets - } - else if (annotated is KtLightParameter && annotated.method.isSetter) { - return target == AnnotationUseSiteTarget.SETTER_PARAMETER - } - - return true -} \ No newline at end of file diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/stubs/KotlinStubVersions.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/stubs/KotlinStubVersions.kt index 5d107b4b4fe..29d85b2b812 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/stubs/KotlinStubVersions.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/stubs/KotlinStubVersions.kt @@ -28,7 +28,7 @@ object KotlinStubVersions { // Binary stub version should be increased if stub format (org.jetbrains.kotlin.psi.stubs.impl) is changed // or changes are made to the core stub building code (org.jetbrains.kotlin.idea.decompiler.stubBuilder). // Increasing this version will lead to reindexing of all binary files that are potentially kotlin binaries (including all class files). - private const val BINARY_STUB_VERSION = 68 + private const val BINARY_STUB_VERSION = 69 // Classfile stub version should be increased if changes are made to classfile stub building subsystem (org.jetbrains.kotlin.idea.decompiler.classFile) // Increasing this version will lead to reindexing of all classfiles. diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index fe65cf21360..5944c196154 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt @@ -164,7 +164,10 @@ class DescriptorSerializer private constructor( val compileTimeConstant = descriptor.compileTimeInitializer val hasConstant = compileTimeConstant != null && compileTimeConstant !is NullValue - val hasAnnotations = descriptor.annotations.getAllAnnotations().isNotEmpty() + val hasAnnotations = + !descriptor.annotations.isEmpty() || + descriptor.backingField?.annotations?.isEmpty() == false || + descriptor.delegateField?.annotations?.isEmpty() == false val propertyFlags = Flags.getAccessorFlags( hasAnnotations, diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.txt index 34088b456a0..2c941e8ce39 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.txt @@ -1,7 +1,7 @@ package package a { - @java.lang.Deprecated @java.lang.SuppressWarnings(value = {}) public val s: kotlin.String = "" + @field:java.lang.Deprecated @field:java.lang.SuppressWarnings(value = {}) public val s: kotlin.String = "" @java.lang.Deprecated @java.lang.SuppressWarnings(value = {}) public fun main(/*0*/ args: kotlin.Array): kotlin.Unit public final class Test { diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-negative.txt b/compiler/testData/diagnostics/tests/annotations/kt1860-negative.txt index c461b7bf5cc..caa8c915e63 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1860-negative.txt +++ b/compiler/testData/diagnostics/tests/annotations/kt1860-negative.txt @@ -1,6 +1,6 @@ package -public var bar: kotlin.Int +@setparam:[ERROR : varargs] /* annotation class not found */ public var bar: kotlin.Int public val x: (kotlin.Int) -> kotlin.Int public fun foo(/*0*/ @[ERROR : varargs] /* annotation class not found */ f: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt index c6a03499401..1e586c8b490 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt +++ b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt @@ -1,6 +1,6 @@ package -public var bar: kotlin.Int +@setparam:test public var bar: kotlin.Int public val x: (kotlin.Int) -> kotlin.Int public fun foo(/*0*/ @test f: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt b/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt index f709e8f8a98..0977c596a6d 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt @@ -1,6 +1,6 @@ package -public var x: kotlin.Int +@setparam:Ann public var x: kotlin.Int @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class Ann : kotlin.Annotation { public constructor Ann() diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/field.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/field.txt index f99b6907fd2..1e6ceea09ec 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/field.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/field.txt @@ -1,6 +1,6 @@ package -@Field public val x: kotlin.Int = 42 +@field:Field public val x: kotlin.Int = 42 @Field public val y: kotlin.Int @Field public final annotation class Another : kotlin.Annotation { @@ -28,8 +28,8 @@ public interface His { @Field public abstract class My { public constructor My(/*0*/ @Field arg: kotlin.Int, /*1*/ w: kotlin.Int) @Field public final val v: kotlin.Int - @Field public final val w: kotlin.Int - @Field public final val x: kotlin.Int + @field:Field public final val w: kotlin.Int + @field:Field public final val x: kotlin.Int @Field public final val y: kotlin.Int @Field public abstract val z: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt index f0246c01b41..c8d5a703728 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt @@ -75,8 +75,8 @@ package test { @test.AnnotationTargets.base @test.AnnotationTargets.meta @test.AnnotationTargets.type @test.AnnotationTargets.method @test.AnnotationTargets.multiple public final class KClass { @test.AnnotationTargets.base @test.AnnotationTargets.method @test.AnnotationTargets.konstructor public constructor KClass() public constructor KClass(/*0*/ @test.AnnotationTargets.base @test.AnnotationTargets.parameter y: @test.AnnotationTargets.base @test.AnnotationTargets.type kotlin.Int) - @test.AnnotationTargets.base @test.AnnotationTargets.multiple @test.AnnotationTargets.fieldann @test.AnnotationTargets.local public final val x: kotlin.Int = 0 - @test.AnnotationTargets.fieldann public final val y: @test.AnnotationTargets.base @test.AnnotationTargets.type kotlin.Int + @test.AnnotationTargets.base @test.AnnotationTargets.local @field:test.AnnotationTargets.multiple @field:test.AnnotationTargets.fieldann public final val x: kotlin.Int = 0 + @field:test.AnnotationTargets.fieldann public final val y: @test.AnnotationTargets.base @test.AnnotationTargets.type kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @test.AnnotationTargets.base @test.AnnotationTargets.method @test.AnnotationTargets.multiple @test.AnnotationTargets.konstructor public final fun foo(/*0*/ @test.AnnotationTargets.parameter @test.AnnotationTargets.type i: @test.AnnotationTargets.base @test.AnnotationTargets.multiple kotlin.Int): @test.AnnotationTargets.fieldann @test.AnnotationTargets.parameter kotlin.Int public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt b/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt index e3f05e5af04..45f8b96a441 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt @@ -1,7 +1,7 @@ package @unrepann(x = 0) public var annotated: kotlin.Int -@unrepann(x = 0) @property:unrepann(x = 1) public var annotated2: kotlin.Int +@unrepann(x = 0) @unrepann(x = 1) public var annotated2: kotlin.Int @ann(y = 0) @ann(y = 1) public fun foo(/*0*/ @ann(y = 7) @ann(y = 2) x: kotlin.Int): kotlin.Int @unrepann(x = 1) @unrepann(x = 2) public final class DoubleAnnotated { diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.txt index 52548d9bb58..564640865b2 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.txt @@ -1,6 +1,6 @@ package -public fun foo(/*0*/ @delegate:Field @delegate:Prop x: kotlin.Int): kotlin.Int +public fun foo(/*0*/ x: kotlin.Int): kotlin.Int public final class CustomDelegate { public constructor CustomDelegate() @@ -24,19 +24,19 @@ public final class CustomDelegate { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@delegate:Field public final class SomeClass { - @delegate:Field public constructor SomeClass() +public final class SomeClass { + public constructor SomeClass() @delegate:Field @delegate:Prop protected final val delegatedProperty: kotlin.String - @delegate:Field @delegate:Prop public final val propertyWithCustomGetter: kotlin.Int - @delegate:Field @delegate:Prop protected final val simpleProperty: kotlin.String = "text" + public final val propertyWithCustomGetter: kotlin.Int + protected final val simpleProperty: kotlin.String = "text" 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 } public final class WithPrimaryConstructor { - public constructor WithPrimaryConstructor(/*0*/ a: kotlin.String, /*1*/ @param:Field @param:Prop b: kotlin.String) - @delegate:Field @delegate:Prop public final val a: kotlin.String + public constructor WithPrimaryConstructor(/*0*/ a: kotlin.String, /*1*/ @Field @Prop b: kotlin.String) + public final val a: kotlin.String public final val b: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt index b2c2251d547..88953b83e49 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt @@ -15,13 +15,13 @@ public final class CustomDelegate { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@field:Ann public final class SomeClass { - @field:Ann public constructor SomeClass() - @field:Ann protected final val delegatedProperty: kotlin.String - @field:Ann public final val propertyWithCustomGetter: kotlin.Int +public final class SomeClass { + public constructor SomeClass() + protected final val delegatedProperty: kotlin.String + public final val propertyWithCustomGetter: kotlin.Int @field:Ann protected final val simpleProperty: kotlin.String = "text" @field:Ann protected final val simplePropertyWithAnnotationList: kotlin.String = "text" - @field:Ann public final fun anotherFun(/*0*/ @field:Ann s: kotlin.String): kotlin.Unit + public final fun anotherFun(/*0*/ s: kotlin.String): kotlin.Unit 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/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt index b39b0cc952e..68b3511ffa4 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt @@ -15,14 +15,14 @@ public final class CustomDelegate { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@get:Ann public final class SomeClass { - @get:Ann public constructor SomeClass() +public final class SomeClass { + public constructor SomeClass() protected final val delegatedProperty: kotlin.String protected final var mutableProperty: kotlin.String public final val propertyWithCustomGetter: kotlin.Int protected final val simpleProperty: kotlin.String = "text" protected final val simplePropertyWithAnnotationList: kotlin.String = "text" - @get:Ann public final fun annotationOnFunction(/*0*/ a: kotlin.Int): kotlin.Int + public final fun annotationOnFunction(/*0*/ a: kotlin.Int): kotlin.Int public final fun anotherFun(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt index 3ca65733687..2596a2bca2e 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt @@ -8,7 +8,7 @@ public final annotation class Ann : kotlin.Annotation { } public final class PrimaryConstructorClass { - public constructor PrimaryConstructorClass(/*0*/ @param:Ann a: kotlin.String, /*1*/ @param:Ann @param:Second b: kotlin.String, /*2*/ @param:Ann c: kotlin.String) + public constructor PrimaryConstructorClass(/*0*/ a: kotlin.String, /*1*/ b: kotlin.String, /*2*/ @Ann c: kotlin.String) public final val c: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -22,10 +22,10 @@ public final annotation class Second : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@param:Ann public final class SomeClass { - @param:Ann public constructor SomeClass(/*0*/ @param:Ann a: kotlin.String) - @param:Ann protected final val simpleProperty: kotlin.String = "text" - @param:Ann public final fun anotherFun(): kotlin.Unit +public final class SomeClass { + public constructor SomeClass(/*0*/ a: kotlin.String) + protected final val simpleProperty: kotlin.String = "text" + public final fun anotherFun(): kotlin.Unit 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/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt index 21da3e069cd..79e2dd175fe 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt @@ -22,14 +22,14 @@ public final annotation class Second : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@property:Ann public final class SomeClass { - @property:Ann public constructor SomeClass(/*0*/ s: kotlin.String) - @property:Ann protected final val p1: kotlin.String = "" - @property:Ann @property:Second protected final val p2: kotlin.String = "" - @property:Ann protected final var p3: kotlin.String - @property:Ann protected final val p4: kotlin.String - @property:Ann public final var propertyWithCustomSetter: kotlin.Int - @property:Ann public final fun anotherFun(): kotlin.Unit +public final class SomeClass { + public constructor SomeClass(/*0*/ s: kotlin.String) + @Ann protected final val p1: kotlin.String = "" + @Ann @Second protected final val p2: kotlin.String = "" + @Ann protected final var p3: kotlin.String + @Ann protected final val p4: kotlin.String + @Ann public final var propertyWithCustomSetter: kotlin.Int + public final fun anotherFun(): kotlin.Unit 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/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt index 12356582c0b..62db3c82aff 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt @@ -10,11 +10,11 @@ public final annotation class Ann : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@receiver:Ann public final class SomeClass { - @receiver:Ann public constructor SomeClass(/*0*/ @receiver:Ann a: kotlin.String) - @receiver:Ann protected final val simpleProperty: kotlin.String = "text" +public final class SomeClass { + public constructor SomeClass(/*0*/ a: kotlin.String) + protected final val simpleProperty: kotlin.String = "text" public final val @receiver:Ann kotlin.String.extensionProperty2: kotlin.String - @receiver:Ann public final fun anotherFun(): kotlin.Unit + public final fun anotherFun(): kotlin.Unit 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/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt index 85fee30cfed..9f06d405834 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt @@ -16,14 +16,14 @@ public final class CustomDelegate { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@set:Ann public final class SomeClass { +public final class SomeClass { public constructor SomeClass() protected final var delegatedProperty: kotlin.String protected final var mutableProperty: kotlin.String protected final var mutablePropertyWithAnnotationList: kotlin.String public final var propertyWithCustomSetter: kotlin.Int - @set:Ann protected final val simpleProperty: kotlin.String = "text" - @set:Ann public final fun annotationOnFunction(/*0*/ a: kotlin.Int): kotlin.Int + protected final val simpleProperty: kotlin.String = "text" + public final fun annotationOnFunction(/*0*/ a: kotlin.Int): kotlin.Int public final fun anotherFun(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt index 142b940d923..76279334f47 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt @@ -16,14 +16,14 @@ public final class CustomDelegate { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@setparam:Ann public final class SomeClass { - @setparam:Ann public constructor SomeClass() +public final class SomeClass { + public constructor SomeClass() @setparam:Ann protected final var delegatedProperty: kotlin.String @setparam:Ann protected final var mutableProperty: kotlin.String @setparam:Ann protected final var mutablePropertyWithAnnotationList: kotlin.String @setparam:Ann public final var propertyWithCustomSetter: kotlin.Int - @setparam:Ann protected final val simpleProperty: kotlin.String = "text" - @setparam:Ann public final fun anotherFun(): kotlin.Unit + protected final val simpleProperty: kotlin.String = "text" + public final fun anotherFun(): kotlin.Unit 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/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.txt index c2d212717dd..c67269852c3 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.txt @@ -1,10 +1,10 @@ package package bar { - @file:bar.foo public val prop: [ERROR : No type, no body] - @file:bar.bar @file:bar.baz public fun func(): kotlin.Unit + public val prop: [ERROR : No type, no body] + public fun func(): kotlin.Unit - @file:bar.baz public final class C { + public final class C { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.txt index eec44209c80..96df61a23ae 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.txt @@ -1,6 +1,6 @@ package -@foo @bar @file:baz public fun test(): kotlin.Unit +@foo @bar public fun test(): kotlin.Unit public final annotation class bar : kotlin.Annotation { public constructor bar() diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.txt index eec44209c80..96df61a23ae 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.txt @@ -1,6 +1,6 @@ package -@foo @bar @file:baz public fun test(): kotlin.Unit +@foo @bar public fun test(): kotlin.Unit public final annotation class bar : kotlin.Annotation { public constructor bar() diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.txt index bd38106f5ba..f588f2fd6b1 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.txt @@ -1,11 +1,11 @@ package -public fun test1(/*0*/ @file:kotlin.Suppress(names = {""}) x: kotlin.Int): kotlin.Unit -@file:kotlin.Suppress(names = {""}) public fun test2(): kotlin.Unit -public fun @file:kotlin.Suppress(names = {""}) kotlin.Int.test3(): kotlin.Unit +public fun test1(/*0*/ x: kotlin.Int): kotlin.Unit +public fun test2(): kotlin.Unit +public fun kotlin.Int.test3(): kotlin.Unit public final class OnType { - public constructor OnType(/*0*/ x: @file:kotlin.Suppress(names = {""}) kotlin.Int) + public constructor OnType(/*0*/ x: kotlin.Int) 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/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.txt index bd38106f5ba..f588f2fd6b1 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.txt @@ -1,11 +1,11 @@ package -public fun test1(/*0*/ @file:kotlin.Suppress(names = {""}) x: kotlin.Int): kotlin.Unit -@file:kotlin.Suppress(names = {""}) public fun test2(): kotlin.Unit -public fun @file:kotlin.Suppress(names = {""}) kotlin.Int.test3(): kotlin.Unit +public fun test1(/*0*/ x: kotlin.Int): kotlin.Unit +public fun test2(): kotlin.Unit +public fun kotlin.Int.test3(): kotlin.Unit public final class OnType { - public constructor OnType(/*0*/ x: @file:kotlin.Suppress(names = {""}) kotlin.Int) + public constructor OnType(/*0*/ x: kotlin.Int) 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/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_after.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_after.txt index 4036b4ab0c4..f4663c38dfd 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_after.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_after.txt @@ -1,8 +1,8 @@ package public val @receiver:Fancy kotlin.Int.asVal: kotlin.Int -public fun ((@receiver:Fancy kotlin.Int) -> kotlin.Unit).complexReceiver1(): kotlin.Unit -public fun ((kotlin.Int) -> @receiver:Fancy kotlin.Unit).complexReceiver2(): kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).complexReceiver1(): kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).complexReceiver2(): kotlin.Unit public fun @receiver:Fancy kotlin.String.myExtension(): kotlin.Unit @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class Fancy : kotlin.Annotation { diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_before.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_before.txt index 4036b4ab0c4..f4663c38dfd 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_before.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_before.txt @@ -1,8 +1,8 @@ package public val @receiver:Fancy kotlin.Int.asVal: kotlin.Int -public fun ((@receiver:Fancy kotlin.Int) -> kotlin.Unit).complexReceiver1(): kotlin.Unit -public fun ((kotlin.Int) -> @receiver:Fancy kotlin.Unit).complexReceiver2(): kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).complexReceiver1(): kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).complexReceiver2(): kotlin.Unit public fun @receiver:Fancy kotlin.String.myExtension(): kotlin.Unit @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class Fancy : kotlin.Annotation { diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt index 349d818575b..05fd78fb215 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt @@ -1,16 +1,16 @@ package public final class A { - public constructor A(/*0*/ @param:Ann @Ann x: kotlin.Int, /*1*/ @param:RepeatableAnn @Ann y: kotlin.Int) - @property:Ann @RepeatableAnn @property:RepeatableAnn @field:Ann public final val a: kotlin.Int = 0 - @Ann @property:Ann @field:Ann public final val b: kotlin.Int = 0 + public constructor A(/*0*/ @Ann @Ann x: kotlin.Int, /*1*/ @RepeatableAnn @Ann y: kotlin.Int) + @Ann @RepeatableAnn @RepeatableAnn @field:Ann public final val a: kotlin.Int = 0 + @Ann @Ann @field:Ann public final val b: kotlin.Int = 0 @field:RepeatableAnn @field:RepeatableAnn public final val c: kotlin.Int = 0 - @property:RepeatableAnn @RepeatableAnn public final val d: kotlin.Int = 0 - @property:RepeatableAnn @RepeatableAnn @delegate:RepeatableAnn public final val e: kotlin.String - @property:Ann @delegate:Ann public final val f: kotlin.String + @RepeatableAnn @RepeatableAnn public final val d: kotlin.Int = 0 + @RepeatableAnn @RepeatableAnn @delegate:RepeatableAnn public final val e: kotlin.String + @Ann @delegate:Ann public final val f: kotlin.String @Ann @delegate:Ann public final val g: kotlin.String @Ann @field:Ann public final val h: kotlin.String = "" - @property:Ann @field:Ann public final val i: kotlin.String = "" + @Ann @field:Ann public final val i: kotlin.String = "" public final val x: kotlin.Int public final val y: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -26,10 +26,10 @@ public final annotation class Ann : kotlin.Annotation { } public final class B { - public constructor B(/*0*/ @param:fieldOrPropAnn x: kotlin.Int, /*1*/ y: kotlin.Int) + public constructor B(/*0*/ @fieldOrPropAnn x: kotlin.Int, /*1*/ y: kotlin.Int) @getSetAndParamAnn @setparam:getSetAndParamAnn public final var w: kotlin.Int @fieldOrPropAnn public final val x: kotlin.Int - @property:fieldOrPropAnn @fieldOrPropAnn public final val y: kotlin.Int + @fieldOrPropAnn @fieldOrPropAnn public final val y: kotlin.Int @fieldOrPropAnn @field:fieldOrPropAnn public final val z: kotlin.Int = 42 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypesError.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypesError.txt index 7f4539dbea7..838171d3a7f 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypesError.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypesError.txt @@ -1,9 +1,9 @@ package -public fun test1(/*0*/ i: @setparam:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test2(/*0*/ i: @param:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test3(/*0*/ i: @receiver:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test4(): @setparam:kotlin.Suppress(names = {}) kotlin.Int -public fun test5(/*0*/ i: (@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit): kotlin.Unit -public fun test7(): (@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit -public fun ((@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit).test6(): kotlin.Unit +public fun test1(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test2(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test3(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test4(): kotlin.Int +public fun test5(/*0*/ i: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public fun test7(): (kotlin.Int) -> kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).test6(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_after.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_after.txt index 7f4539dbea7..838171d3a7f 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_after.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_after.txt @@ -1,9 +1,9 @@ package -public fun test1(/*0*/ i: @setparam:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test2(/*0*/ i: @param:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test3(/*0*/ i: @receiver:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test4(): @setparam:kotlin.Suppress(names = {}) kotlin.Int -public fun test5(/*0*/ i: (@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit): kotlin.Unit -public fun test7(): (@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit -public fun ((@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit).test6(): kotlin.Unit +public fun test1(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test2(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test3(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test4(): kotlin.Int +public fun test5(/*0*/ i: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public fun test7(): (kotlin.Int) -> kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).test6(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_before.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_before.txt index 7f4539dbea7..838171d3a7f 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_before.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_before.txt @@ -1,9 +1,9 @@ package -public fun test1(/*0*/ i: @setparam:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test2(/*0*/ i: @param:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test3(/*0*/ i: @receiver:kotlin.Suppress(names = {}) kotlin.Int): kotlin.Unit -public fun test4(): @setparam:kotlin.Suppress(names = {}) kotlin.Int -public fun test5(/*0*/ i: (@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit): kotlin.Unit -public fun test7(): (@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit -public fun ((@setparam:kotlin.Suppress(names = {}) kotlin.Int) -> kotlin.Unit).test6(): kotlin.Unit +public fun test1(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test2(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test3(/*0*/ i: kotlin.Int): kotlin.Unit +public fun test4(): kotlin.Int +public fun test5(/*0*/ i: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public fun test7(): (kotlin.Int) -> kotlin.Unit +public fun ((kotlin.Int) -> kotlin.Unit).test6(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.txt b/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.txt index b92751f84ad..f0b7c450610 100644 --- a/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.txt +++ b/compiler/testData/diagnostics/tests/deprecated/javaDeprecated.txt @@ -10,7 +10,7 @@ package public final class B : A { public constructor B(/*0*/ foo: kotlin.String) - @property:kotlin.Deprecated private final val foo: kotlin.String + @kotlin.Deprecated private final val foo: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ fun getFoo(/*0*/ text: kotlin.String): kotlin.String public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.txt b/compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.txt index 9d5e1f4dba8..b285f275262 100644 --- a/compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.txt +++ b/compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.txt @@ -6,7 +6,7 @@ public fun literals(): kotlin.Unit public final class PropertyHolder { public constructor PropertyHolder() @kotlin.Deprecated(message = "") public final val a1: kotlin.Int = 1 - @property:kotlin.Deprecated(message = "") public final var a2: kotlin.String + @kotlin.Deprecated(message = "") public final var a2: kotlin.String public final val withGetter: kotlin.String = "" public final var withSetter: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameProhibitedOnExtensionProperty.txt b/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameProhibitedOnExtensionProperty.txt index dd90243bbbe..1fa6445e7c1 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameProhibitedOnExtensionProperty.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameProhibitedOnExtensionProperty.txt @@ -2,7 +2,7 @@ package package foo { @kotlin.js.JsName(name = "xx") public val foo.A.x: kotlin.Int - @property:kotlin.js.JsName(name = "yy") public val foo.A.y: kotlin.Int + @kotlin.js.JsName(name = "yy") public val foo.A.y: kotlin.Int public final class A { public constructor A() diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameUseTargetOnProperty.txt b/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameUseTargetOnProperty.txt index 378b54946ed..05e34586e25 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameUseTargetOnProperty.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameUseTargetOnProperty.txt @@ -2,7 +2,7 @@ package public final class A { public constructor A() - @property:kotlin.js.JsName(name = "x_") public final val x: kotlin.Int = 0 + @kotlin.js.JsName(name = "x_") public final val x: kotlin.Int = 0 public final var y: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.txt index ffd73543679..b6d31436690 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.txt @@ -3,8 +3,8 @@ package public final class My { public constructor My() @field:kotlin.jvm.Volatile public final val w: kotlin.Int = 2 - @kotlin.jvm.Volatile public final val x: kotlin.Int = 0 - @kotlin.jvm.Volatile public final var y: kotlin.Int + @field:kotlin.jvm.Volatile public final val x: kotlin.Int = 0 + @field:kotlin.jvm.Volatile public final var y: kotlin.Int @delegate:kotlin.jvm.Volatile public final var z: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt index 30da1567767..ab1257d91c0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt @@ -1,6 +1,6 @@ interface Test { - @get:JvmStatic - val a: Int + @get:JvmStatic + val a: Int @get:JvmName("1") val b: Int @@ -8,6 +8,6 @@ interface Test { @get:Synchronized val c: Int - @get:JvmOverloads + @get:JvmOverloads val d: Int -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingNonExistentAccessor.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingNonExistentAccessor.txt index b6838100b81..3cdc0a361c1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingNonExistentAccessor.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingNonExistentAccessor.txt @@ -59,9 +59,9 @@ public final class Foo { } private final class Other { - public constructor Other(/*0*/ @param:Ann param: kotlin.Int) + public constructor Other(/*0*/ @Ann param: kotlin.Int) @delegate:Ann private final val delegate: kotlin.String - @property:Ann @field:Ann private final val other: kotlin.String = "" + @Ann @field:Ann private final val other: kotlin.String = "" private final val param: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -94,7 +94,7 @@ public final class Statics { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final val x0: kotlin.String = "" + @field:kotlin.jvm.JvmField public final val x0: kotlin.String = "" public const final val x1: kotlin.String = "" @kotlin.jvm.JvmStatic public final val x2: kotlin.String = "" @kotlin.jvm.JvmStatic private final val x3: kotlin.String = "" diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.txt index ae11fa6f14f..dc9e81a503f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.txt @@ -2,7 +2,7 @@ package public final class A { public constructor A() - @kotlin.jvm.JvmField public final val clash: kotlin.Int = 1 + @field:kotlin.jvm.JvmField public final val clash: kotlin.Int = 1 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/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.txt index 9f5bde826e1..40df13e4c9c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.txt @@ -1,11 +1,11 @@ package -@kotlin.jvm.JvmField public val c: kotlin.Int = 4 -@kotlin.jvm.JvmField public var g: kotlin.Int +@field:kotlin.jvm.JvmField public val c: kotlin.Int = 4 +@field:kotlin.jvm.JvmField public var g: kotlin.Int public final class C { public constructor C() - @kotlin.jvm.JvmField public final var g: kotlin.Int + @field:kotlin.jvm.JvmField public final var g: kotlin.Int 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/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.txt index 9f5bde826e1..40df13e4c9c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.txt @@ -1,11 +1,11 @@ package -@kotlin.jvm.JvmField public val c: kotlin.Int = 4 -@kotlin.jvm.JvmField public var g: kotlin.Int +@field:kotlin.jvm.JvmField public val c: kotlin.Int = 4 +@field:kotlin.jvm.JvmField public var g: kotlin.Int public final class C { public constructor C() - @kotlin.jvm.JvmField public final var g: kotlin.Int + @field:kotlin.jvm.JvmField public final var g: kotlin.Int 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/diagnostics/testsWithStdLib/annotations/jvmField/interface13.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/interface13.txt index 14c48063f67..1020d61e38e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/interface13.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/interface13.txt @@ -7,7 +7,7 @@ public interface A { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final val c: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public final val c: kotlin.Int = 3 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 @@ -21,8 +21,8 @@ public interface B { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final val a: kotlin.Int = 3 - @kotlin.jvm.JvmField public final val c: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public final val a: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public final val c: kotlin.Int = 3 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 @@ -37,7 +37,7 @@ public interface C { public companion object Companion { private constructor Companion() public final val a: kotlin.Int = 3 - @kotlin.jvm.JvmField public final val c: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public final val c: kotlin.Int = 3 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 @@ -51,7 +51,7 @@ public interface D { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final var c: kotlin.Int + @field:kotlin.jvm.JvmField public final var c: kotlin.Int 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 @@ -65,9 +65,9 @@ public interface E { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField private final val a: kotlin.Int = 3 - @kotlin.jvm.JvmField internal final val b: kotlin.Int = 3 - @kotlin.jvm.JvmField protected final val c: kotlin.Int = 3 + @field:kotlin.jvm.JvmField private final val a: kotlin.Int = 3 + @field:kotlin.jvm.JvmField internal final val b: kotlin.Int = 3 + @field:kotlin.jvm.JvmField protected final val c: kotlin.Int = 3 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 @@ -81,7 +81,7 @@ public interface F { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public open val a: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public open val a: kotlin.Int = 3 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/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.kt index 0162d77b908..e5b58ebd39d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.kt @@ -17,7 +17,7 @@ abstract class C : I{ @kotlin.jvm.JvmField private fun foo(s: String = "OK") { } - @JvmField val a: String by lazy { "A" } + @JvmField val a: String by lazy { "A" } @JvmField open val b: Int = 3 diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.txt index 7a971bf5f0e..0a93626031d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.txt @@ -1,25 +1,25 @@ package -@kotlin.jvm.JvmField public const val Const: kotlin.Int = 4 -@kotlin.jvm.JvmField public var i: kotlin.Int -@kotlin.jvm.JvmField private val private: kotlin.Int = 3 +@field:kotlin.jvm.JvmField public const val Const: kotlin.Int = 4 +@field:kotlin.jvm.JvmField public var i: kotlin.Int +@field:kotlin.jvm.JvmField private val private: kotlin.Int = 3 @kotlin.jvm.JvmField public fun foo(): kotlin.Unit @kotlin.jvm.JvmField public abstract class C : I { @kotlin.jvm.JvmField public constructor C(/*0*/ s: kotlin.String) @kotlin.jvm.JvmField public final val a: kotlin.String - @kotlin.jvm.JvmField public final override /*1*/ val ai: kotlin.Int = 3 - @kotlin.jvm.JvmField public open val b: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public final override /*1*/ val ai: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public open val b: kotlin.Int = 3 @kotlin.jvm.JvmField public open override /*1*/ /*fake_override*/ val bi: kotlin.Int @kotlin.jvm.JvmField public abstract val c: kotlin.Int - @kotlin.jvm.JvmField public final val customGetter: kotlin.String = "" - @kotlin.jvm.JvmField public final var customSetter: kotlin.String - @kotlin.jvm.JvmField public final val explicitDefaultAnnotatedGetter: kotlin.String = "" - @kotlin.jvm.JvmField public final var explicitDefaultAnnotatedSetter: kotlin.String - @kotlin.jvm.JvmField public final val explicitDefaultGetter: kotlin.String = "" - @kotlin.jvm.JvmField public final var explicitDefaultSetter: kotlin.String + @field:kotlin.jvm.JvmField public final val customGetter: kotlin.String = "" + @field:kotlin.jvm.JvmField public final var customSetter: kotlin.String + @field:kotlin.jvm.JvmField public final val explicitDefaultAnnotatedGetter: kotlin.String = "" + @field:kotlin.jvm.JvmField public final var explicitDefaultAnnotatedSetter: kotlin.String + @field:kotlin.jvm.JvmField public final val explicitDefaultGetter: kotlin.String = "" + @field:kotlin.jvm.JvmField public final var explicitDefaultSetter: kotlin.String @kotlin.jvm.JvmField public final val noBackingField: kotlin.String - @kotlin.jvm.JvmField private final val private: kotlin.Int = 3 + @field:kotlin.jvm.JvmField private final val private: kotlin.Int = 3 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @kotlin.jvm.JvmField private final fun foo(/*0*/ s: kotlin.String = ...): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -35,7 +35,7 @@ public final annotation class DemoAnnotation : kotlin.Annotation { public final class G { public constructor G() - @kotlin.jvm.JvmField public final lateinit var lateInit: kotlin.String + @field:kotlin.jvm.JvmField public final lateinit var lateInit: kotlin.String @delegate:kotlin.jvm.JvmField public final val s: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -50,7 +50,7 @@ public final class H { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final var c: kotlin.Int + @field:kotlin.jvm.JvmField public final var c: kotlin.Int 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 @@ -74,7 +74,7 @@ public interface K { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final var c: kotlin.Int + @field:kotlin.jvm.JvmField public final var c: kotlin.Int public final var x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -84,8 +84,8 @@ public interface K { public final class KK : K { public constructor KK() - @kotlin.jvm.JvmField public open override /*1*/ val i: kotlin.Int = 0 - @kotlin.jvm.JvmField public final override /*1*/ val j: kotlin.Int = 0 + @field:kotlin.jvm.JvmField public open override /*1*/ val i: kotlin.Int = 0 + @field:kotlin.jvm.JvmField public final override /*1*/ val j: kotlin.Int = 0 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 @@ -93,8 +93,8 @@ public final class KK : K { public open class KKK : K { public constructor KKK() - @kotlin.jvm.JvmField public open override /*1*/ val i: kotlin.Int = 0 - @kotlin.jvm.JvmField public final override /*1*/ val j: kotlin.Int = 0 + @field:kotlin.jvm.JvmField public open override /*1*/ val i: kotlin.Int = 0 + @field:kotlin.jvm.JvmField public final override /*1*/ val j: kotlin.Int = 0 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 @@ -108,7 +108,7 @@ public final annotation class L : kotlin.Annotation { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmField public final var c: kotlin.Int + @field:kotlin.jvm.JvmField public final var c: kotlin.Int 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 @@ -117,7 +117,7 @@ public final annotation class L : kotlin.Annotation { public object O { private constructor O() - @kotlin.jvm.JvmField public final val c: kotlin.Int = 3 + @field:kotlin.jvm.JvmField public final val c: kotlin.Int = 3 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/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.txt index ba1ebbb19c5..af6c64dade2 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.txt @@ -8,7 +8,7 @@ public final class A { public companion object Companion { private constructor Companion() - @kotlin.jvm.JvmStatic @kotlin.jvm.JvmField public final val x: kotlin.Int = 1 + @kotlin.jvm.JvmStatic @field:kotlin.jvm.JvmField public final val x: kotlin.Int = 1 @kotlin.jvm.JvmStatic public const final val z: kotlin.Int = 1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -18,7 +18,7 @@ public final class A { public object B { private constructor B() - @kotlin.jvm.JvmStatic @kotlin.jvm.JvmField public final val x: kotlin.Int = 1 + @kotlin.jvm.JvmStatic @field:kotlin.jvm.JvmField public final val x: kotlin.Int = 1 @kotlin.jvm.JvmStatic public const final val z: kotlin.Int = 1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JvmAbi.java b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JvmAbi.java index fe15481f4a3..ec2ed38f473 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JvmAbi.java +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JvmAbi.java @@ -7,19 +7,12 @@ package org.jetbrains.kotlin.load.java; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.builtins.CompanionObjectMapping; -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor; -import org.jetbrains.kotlin.descriptors.ClassDescriptor; -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; -import org.jetbrains.kotlin.descriptors.PropertyDescriptor; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget; +import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.name.ClassId; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.util.capitalizeDecapitalize.CapitalizeDecapitalizeKt; -import java.util.List; - import static org.jetbrains.kotlin.resolve.DescriptorUtils.isClassOrEnumClass; import static org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject; @@ -120,12 +113,10 @@ public final class JvmAbi { } public static boolean hasJvmFieldAnnotation(@NotNull CallableMemberDescriptor memberDescriptor) { - List annotations = memberDescriptor.getAnnotations().getUseSiteTargetedAnnotations(); - for (AnnotationWithTarget annotationWithTarget : annotations) { - if (AnnotationUseSiteTarget.FIELD.equals(annotationWithTarget.getTarget()) && - JVM_FIELD_ANNOTATION_FQ_NAME.equals(annotationWithTarget.getAnnotation().getFqName())) { - return true; - } + // TODO: deduplicate this with org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmFieldAnnotation + if (memberDescriptor instanceof PropertyDescriptor) { + FieldDescriptor field = ((PropertyDescriptor) memberDescriptor).getBackingField(); + if (field != null && field.getAnnotations().hasAnnotation(JVM_FIELD_ANNOTATION_FQ_NAME)) return true; } return memberDescriptor.getAnnotations().hasAnnotation(JVM_FIELD_ANNOTATION_FQ_NAME); } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java index 031c4db26f5..c3bda3aea38 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java @@ -131,7 +131,7 @@ public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements Ja newSetter.initialize(setter.getValueParameters().get(0)); } - enhanced.initialize(newGetter, newSetter); + enhanced.initialize(newGetter, newSetter, getBackingField(), getDelegateField()); enhanced.setSetterProjectedOut(isSetterProjectedOut()); if (compileTimeInitializer != null) { enhanced.setCompileTimeInitializer(compileTimeInitializer); diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt index b6c92e70408..b93afe5856f 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt @@ -271,7 +271,8 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS private fun resolveProperty(field: JavaField): PropertyDescriptor { val propertyDescriptor = createPropertyDescriptor(field) - propertyDescriptor.initialize(null, null) + // Annotations on Java fields are loaded as property annotations, therefore backingField = null below + propertyDescriptor.initialize(null, null, null, null) val propertyType = getPropertyType(field) diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/FieldDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/FieldDescriptor.kt new file mode 100644 index 00000000000..4f51e572eaf --- /dev/null +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/FieldDescriptor.kt @@ -0,0 +1,12 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.descriptors + +import org.jetbrains.kotlin.descriptors.annotations.Annotated + +interface FieldDescriptor : Annotated { + val correspondingProperty: PropertyDescriptor +} diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyDescriptor.java index 15d88110893..f1b02ea8a4e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyDescriptor.java @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.types.TypeSubstitution; import org.jetbrains.kotlin.types.TypeSubstitutor; import java.util.Collection; @@ -54,6 +53,12 @@ public interface PropertyDescriptor extends VariableDescriptorWithAccessors, Cal @Override Collection getOverriddenDescriptors(); + @Nullable + FieldDescriptor getBackingField(); + + @Nullable + FieldDescriptor getDelegateField(); + @Override PropertyDescriptor substitute(@NotNull TypeSubstitutor substitutor); diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FieldDescriptorImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FieldDescriptorImpl.kt new file mode 100644 index 00000000000..e8718dac1f2 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FieldDescriptorImpl.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.descriptors.impl + +import org.jetbrains.kotlin.descriptors.FieldDescriptor +import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.annotations.AnnotatedImpl +import org.jetbrains.kotlin.descriptors.annotations.Annotations + +class FieldDescriptorImpl( + annotations: Annotations, + override val correspondingProperty: PropertyDescriptor +) : FieldDescriptor, AnnotatedImpl(annotations) diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java index 901f38e64b7..5f53c8fbc7b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java @@ -53,6 +53,8 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp private PropertyGetterDescriptorImpl getter; private PropertySetterDescriptor setter; private boolean setterProjectedOut; + private FieldDescriptor backingField; + private FieldDescriptor delegateField; protected PropertyDescriptorImpl( @NotNull DeclarationDescriptor containingDeclaration, @@ -120,9 +122,23 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp this.dispatchReceiverParameter = dispatchReceiverParameter; } - public void initialize(@Nullable PropertyGetterDescriptorImpl getter, @Nullable PropertySetterDescriptor setter) { + public void initialize( + @Nullable PropertyGetterDescriptorImpl getter, + @Nullable PropertySetterDescriptor setter + ) { + initialize(getter, setter, null, null); + } + + public void initialize( + @Nullable PropertyGetterDescriptorImpl getter, + @Nullable PropertySetterDescriptor setter, + @Nullable FieldDescriptor backingField, + @Nullable FieldDescriptor delegateField + ) { this.getter = getter; this.setter = setter; + this.backingField = backingField; + this.delegateField = delegateField; } public void setSetterProjectedOut(boolean setterProjectedOut) { @@ -413,7 +429,12 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp newSetter.initialize(substitutedValueParameters.get(0)); } - substitutedDescriptor.initialize(newGetter, newSetter); + substitutedDescriptor.initialize( + newGetter, + newSetter, + backingField == null ? null : new FieldDescriptorImpl(backingField.getAnnotations(), substitutedDescriptor), + delegateField == null ? null : new FieldDescriptorImpl(delegateField.getAnnotations(), substitutedDescriptor) + ); if (copyConfiguration.copyOverrides) { Collection overridden = SmartSet.create(); @@ -488,6 +509,18 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp return isActual; } + @Override + @Nullable + public FieldDescriptor getBackingField() { + return backingField; + } + + @Override + @Nullable + public FieldDescriptor getDelegateField() { + return delegateField; + } + @Override public void setOverriddenDescriptors(@NotNull Collection overriddenDescriptors) { //noinspection unchecked diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index acc353216b2..01fa979dd5e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -399,13 +399,13 @@ internal class DescriptorRendererImpl( } } - private fun StringBuilder.renderAnnotations(annotated: Annotated) { + private fun StringBuilder.renderAnnotations(annotated: Annotated, target: AnnotationUseSiteTarget? = null) { if (DescriptorRendererModifier.ANNOTATIONS !in modifiers) return val excluded = if (annotated is KotlinType) excludedTypeAnnotationClasses else excludedAnnotationClasses val annotationFilter = annotationFilter - for ((annotation, target) in annotated.annotations.getAllAnnotations()) { + for (annotation in annotated.annotations) { if (annotation.fqName !in excluded && (annotationFilter == null || annotationFilter(annotation))) { append(renderAnnotation(annotation, target)) if (eachAnnotationOnNewLine) { @@ -685,6 +685,8 @@ internal class DescriptorRendererImpl( private fun renderReceiver(callableDescriptor: CallableDescriptor, builder: StringBuilder) { val receiver = callableDescriptor.extensionReceiverParameter if (receiver != null) { + builder.renderAnnotations(receiver, AnnotationUseSiteTarget.RECEIVER) + val type = receiver.type var result = renderType(type) if (shouldRenderAsPrettyFunctionType(type) && !TypeUtils.isNullableType(type)) { @@ -817,7 +819,7 @@ internal class DescriptorRendererImpl( private fun renderProperty(property: PropertyDescriptor, builder: StringBuilder) { if (!startFromName) { if (!startFromDeclarationKeyword) { - builder.renderAnnotations(property) + renderPropertyAnnotations(property, builder) renderVisibility(property.visibility, builder) renderModifier(builder, property.isConst, "const") renderMemberModifiers(property, builder) @@ -841,6 +843,21 @@ internal class DescriptorRendererImpl( renderWhereSuffix(property.typeParameters, builder) } + private fun renderPropertyAnnotations(property: PropertyDescriptor, builder: StringBuilder) { + if (DescriptorRendererModifier.ANNOTATIONS !in modifiers) return + + builder.renderAnnotations(property) + + property.backingField?.let { builder.renderAnnotations(it, AnnotationUseSiteTarget.FIELD) } + property.delegateField?.let { builder.renderAnnotations(it, AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD) } + + if (propertyAccessorRenderingPolicy == PropertyAccessorRenderingPolicy.NONE) { + property.setter?.valueParameters?.single()?.let { + builder.renderAnnotations(it, AnnotationUseSiteTarget.SETTER_PARAMETER) + } + } + } + private fun renderInitializer(variable: VariableDescriptor, builder: StringBuilder) { if (includePropertyConstant) { variable.compileTimeInitializer?.let { constant -> diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index d492277c940..8acb23ffa68 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt @@ -7,8 +7,10 @@ package org.jetbrains.kotlin.serialization.deserialization import org.jetbrains.kotlin.builtins.isSuspendFunctionType import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.annotations.AnnotationsImpl +import org.jetbrains.kotlin.descriptors.impl.FieldDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.PropertyGetterDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.PropertySetterDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl @@ -29,9 +31,11 @@ class MemberDeserializer(private val c: DeserializationContext) { fun loadProperty(proto: ProtoBuf.Property): PropertyDescriptor { val flags = if (proto.hasFlags()) proto.flags else loadOldFlags(proto.oldFlags) + val propertyAnnotations = getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY) + val property = DeserializedPropertyDescriptor( c.containingDeclaration, null, - getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY), + propertyAnnotations, ProtoEnumFlags.modality(Flags.MODALITY.get(flags)), ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)), Flags.IS_VAR.get(flags), @@ -134,7 +138,19 @@ class MemberDeserializer(private val c: DeserializationContext) { ) } - property.initialize(getter, setter, property.checkExperimentalCoroutine(local.typeDeserializer)) + // TODO: add needed methods to AnnotationAndConstantLoader + val fieldAnnotations = DeserializedAnnotations(c.storageManager) { + propertyAnnotations.getUseSiteTargetedAnnotations() + .filter { it.target == AnnotationUseSiteTarget.FIELD }.map { it.annotation } + } + val delegateAnnotations = DeserializedAnnotations(c.storageManager) { + propertyAnnotations.getUseSiteTargetedAnnotations() + .filter { it.target == AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD }.map { it.annotation } + } + property.initialize( + getter, setter, FieldDescriptorImpl(fieldAnnotations, property), FieldDescriptorImpl(delegateAnnotations, property), + property.checkExperimentalCoroutine(local.typeDeserializer) + ) return property } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberDescriptor.kt index 52cfc3de8e0..0fa3bca8856 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedMemberDescriptor.kt @@ -146,9 +146,11 @@ class DeserializedPropertyDescriptor( fun initialize( getter: PropertyGetterDescriptorImpl?, setter: PropertySetterDescriptor?, + backingField: FieldDescriptor?, + delegateField: FieldDescriptor?, isExperimentalCoroutineInReleaseEnvironment: DeserializedMemberDescriptor.CoroutinesCompatibilityMode ) { - super.initialize(getter, setter) + super.initialize(getter, setter, backingField, delegateField) .also { this.coroutinesExperimentalCompatibilityMode = isExperimentalCoroutineInReleaseEnvironment } }