From d0562b7b906e54a96d86c4fabdadbc8c2465916e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 24 Jul 2015 02:07:42 +0300 Subject: [PATCH] Add SourceElement to AnnotationDescriptor Use KotlinSourceElement in the compiler for annotations resolved from PSI, introduce ReflectAnnotationSource for reflection --- .../load/kotlin/FileBasedKotlinClass.java | 10 +++++-- .../evaluate/ConstantExpressionEvaluator.kt | 8 ++--- .../lazy/descriptors/LazyAnnotations.kt | 14 +++++++-- .../java/components/JavaAnnotationMapper.kt | 30 +++++++++---------- .../LazyJavaAnnotationDescriptor.kt | 4 +++ .../java/typeEnhacement/typeEnhancement.kt | 6 ++-- ...tBinaryClassAnnotationAndConstantLoader.kt | 19 +++++++----- ...aryClassAnnotationAndConstantLoaderImpl.kt | 10 +++---- .../load/kotlin/KotlinJvmBinaryClass.java | 5 ++-- ...eadKotlinClassHeaderAnnotationVisitor.java | 3 +- .../kotlin/reflect/ReflectAnnotationSource.kt | 21 +++++++++++++ .../load/kotlin/reflect/ReflectKotlinClass.kt | 8 +++-- .../kotlin/builtins/KotlinBuiltIns.java | 2 +- .../annotations/AnnotationDescriptor.java | 4 +++ .../annotations/AnnotationDescriptorImpl.java | 12 +++++++- .../deserialization/AnnotationDeserializer.kt | 7 ++--- .../stubBuilder/ClsStubBuilderContext.kt | 5 +++- 17 files changed, 110 insertions(+), 58 deletions(-) create mode 100644 core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectAnnotationSource.kt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java index a5c392f88ce..67a9529da12 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java @@ -20,13 +20,17 @@ import com.intellij.openapi.util.Ref; import kotlin.jvm.functions.Function3; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.load.java.JvmAnnotationNames; import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader; import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor; import org.jetbrains.kotlin.name.ClassId; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; -import org.jetbrains.org.objectweb.asm.*; +import org.jetbrains.org.objectweb.asm.ClassReader; +import org.jetbrains.org.objectweb.asm.ClassVisitor; +import org.jetbrains.org.objectweb.asm.FieldVisitor; +import org.jetbrains.org.objectweb.asm.MethodVisitor; import java.util.*; @@ -149,7 +153,7 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass { private static org.jetbrains.org.objectweb.asm.AnnotationVisitor convertAnnotationVisitor( @NotNull AnnotationVisitor visitor, @NotNull String desc, @NotNull InnerClassesInfo innerClasses ) { - AnnotationArgumentVisitor v = visitor.visitAnnotation(resolveNameByDesc(desc, innerClasses)); + AnnotationArgumentVisitor v = visitor.visitAnnotation(resolveNameByDesc(desc, innerClasses), SourceElement.NO_SOURCE); return v == null ? null : convertAnnotationVisitor(v, innerClasses); } @@ -236,7 +240,7 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass { @Override public org.jetbrains.org.objectweb.asm.AnnotationVisitor visitParameterAnnotation(int parameter, @NotNull String desc, boolean visible) { - AnnotationArgumentVisitor av = v.visitParameterAnnotation(parameter, resolveNameByDesc(desc, innerClasses)); + AnnotationArgumentVisitor av = v.visitParameterAnnotation(parameter, resolveNameByDesc(desc, innerClasses), SourceElement.NO_SOURCE); return av == null ? null : convertAnnotationVisitor(av, innerClasses); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index 468ac4062bc..b04ae298afd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -19,10 +19,7 @@ package org.jetbrains.kotlin.resolve.constants.evaluate import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.kotlin.JetNodeTypes import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ConstructorDescriptor -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.descriptors.VariableDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.lexer.JetTokens @@ -587,7 +584,8 @@ private class ConstantExpressionEvaluatorVisitor( if (DescriptorUtils.isAnnotationClass(classDescriptor)) { val descriptor = AnnotationDescriptorImpl( classDescriptor.getDefaultType(), - constantExpressionEvaluator.resolveAnnotationArguments(call, trace) + constantExpressionEvaluator.resolveAnnotationArguments(call, trace), + SourceElement.NO_SOURCE ) return AnnotationValue(descriptor).wrap() } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt index 68fbd9bd134..45d47bf7470 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt @@ -21,11 +21,15 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.JetAnnotationEntry -import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.AnnotationResolver +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil import org.jetbrains.kotlin.resolve.lazy.LazyEntity import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.resolve.source.toSourceElement import org.jetbrains.kotlin.storage.StorageManager abstract class LazyAnnotationsContext( @@ -98,12 +102,14 @@ public class LazyAnnotationDescriptor( ) } - override fun getType() = type() - private val valueArguments = c.storageManager.createLazyValue { computeValueArguments() } + private val source = annotationEntry.toSourceElement() + + override fun getType() = type() + override fun getAllValueArguments() = valueArguments() private fun computeValueArguments(): Map> { @@ -121,6 +127,8 @@ public class LazyAnnotationDescriptor( .filterValues { it != null } as Map> } + override fun getSource() = source + override fun forceResolveAllContents() { ForceResolveUtil.forceResolveAllContents(getType()) getAllValueArguments() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt index 279ea8667f6..504f7ad49ed 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt @@ -18,29 +18,22 @@ package org.jetbrains.kotlin.load.java.components import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.lazy.descriptors.resolveAnnotation -import org.jetbrains.kotlin.load.java.structure.JavaAnnotation -import org.jetbrains.kotlin.load.java.structure.JavaAnnotationArgument -import org.jetbrains.kotlin.load.java.structure.JavaArrayAnnotationArgument -import org.jetbrains.kotlin.load.java.structure.JavaEnumValueAnnotationArgument -import org.jetbrains.kotlin.resolve.constants.ArrayValue -import org.jetbrains.kotlin.resolve.constants.ConstantValue -import org.jetbrains.kotlin.resolve.constants.EnumValue -import org.jetbrains.kotlin.types.ErrorUtils -import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention -import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.resolve.constants.* -import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory +import org.jetbrains.kotlin.types.ErrorUtils import java.lang.annotation.Retention import java.lang.annotation.Target -import java.util.* +import java.util.EnumSet public object JavaAnnotationMapper { @@ -93,11 +86,16 @@ public object JavaAnnotationMapper { } abstract class AbstractJavaAnnotationDescriptor( + c: LazyJavaResolverContext, annotation: JavaAnnotation?, private val kotlinAnnotationClassDescriptor: ClassDescriptor ): AnnotationDescriptor { + private val source = annotation?.let { c.sourceElementFactory.source(it) } ?: SourceElement.NO_SOURCE + override fun getType() = kotlinAnnotationClassDescriptor.defaultType + override fun getSource() = source + protected val valueParameters: List get() = kotlinAnnotationClassDescriptor.constructors.single().valueParameters @@ -107,7 +105,7 @@ abstract class AbstractJavaAnnotationDescriptor( class JavaDeprecatedAnnotationDescriptor( annotation: JavaAnnotation, c: LazyJavaResolverContext -): AbstractJavaAnnotationDescriptor(annotation, c.module.builtIns.deprecatedAnnotation) { +): AbstractJavaAnnotationDescriptor(c, annotation, c.module.builtIns.deprecatedAnnotation) { private val valueArguments = c.storageManager.createLazyValue { val parameterDescriptor = valueParameters.firstOrNull { @@ -123,7 +121,7 @@ class JavaRetentionRepeatableAnnotationDescriptor( retentionAnnotation: JavaAnnotation?, repeatable: Boolean, c: LazyJavaResolverContext -): AbstractJavaAnnotationDescriptor(retentionAnnotation, c.module.builtIns.annotationAnnotation) { +): AbstractJavaAnnotationDescriptor(c, retentionAnnotation, c.module.builtIns.annotationAnnotation) { private val valueArguments = c.storageManager.createLazyValue { val retentionArgument = when (firstArgument) { @@ -147,7 +145,7 @@ class JavaRetentionRepeatableAnnotationDescriptor( class JavaTargetAnnotationDescriptor( annotation: JavaAnnotation, c: LazyJavaResolverContext -): AbstractJavaAnnotationDescriptor(annotation, c.module.builtIns.targetAnnotation) { +): AbstractJavaAnnotationDescriptor(c, annotation, c.module.builtIns.targetAnnotation) { private val valueArguments = c.storageManager.createLazyValue { val targetArgument = when (firstArgument) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 7f1b30a0a6f..d95fc4cbf8b 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -60,6 +60,8 @@ class LazyJavaAnnotationDescriptor( annotationClass?.getDefaultType() ?: ErrorUtils.createErrorType(fqName.asString()) } + private val source = c.sourceElementFactory.source(javaAnnotation) + private val factory = ConstantValueFactory(c.module.builtIns) override fun getType(): JetType = type() @@ -70,6 +72,8 @@ class LazyJavaAnnotationDescriptor( override fun getAllValueArguments() = allValueArguments() + override fun getSource() = source + private fun computeValueArguments(): Map> { val constructors = getAnnotationClass().getConstructors() if (constructors.isEmpty()) return mapOf() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt index b1d2eb30f36..1ef38fcc189 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/typeEnhancement.kt @@ -18,19 +18,16 @@ package org.jetbrains.kotlin.load.java.typeEnhacement import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassifierDescriptor -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.annotations.CompositeAnnotations import org.jetbrains.kotlin.load.java.JvmAnnotationNames -import org.jetbrains.kotlin.load.java.typeEnhacement.JavaTypeQualifiers import org.jetbrains.kotlin.load.java.typeEnhacement.MutabilityQualifier.MUTABLE import org.jetbrains.kotlin.load.java.typeEnhacement.MutabilityQualifier.READ_ONLY import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NOT_NULL import org.jetbrains.kotlin.load.java.typeEnhacement.NullabilityQualifier.NULLABLE import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.platform.JavaToKotlinClassMap -import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant import org.jetbrains.kotlin.types.* // The index in the lambda is the position of the type component: @@ -177,8 +174,9 @@ private class EnhancedTypeAnnotations(private val fqNameToMatch: FqName) : Annot } private object EnhancedTypeAnnotationDescriptor : AnnotationDescriptor { - private fun throwError() = error("No methods should be called on this descriptor. Only it's presence matters") + private fun throwError() = error("No methods should be called on this descriptor. Only its presence matters") override fun getType() = throwError() override fun getAllValueArguments() = throwError() + override fun getSource() = throwError() override fun toString() = "[EnhancedType]" } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt index 92f20fc795d..27211782282 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.load.kotlin +import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName @@ -47,6 +48,7 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? @@ -54,11 +56,12 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { if (JvmAnnotationNames.isSpecialAnnotation(annotationClassId, true)) return null - return loadAnnotation(annotationClassId, result) + return loadAnnotation(annotationClassId, source, result) } override fun loadClassAnnotations(classProto: ProtoBuf.Class, nameResolver: NameResolver): List { @@ -74,8 +77,8 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader(1) kotlinClass.loadClassAnnotations(object : KotlinJvmBinaryClass.AnnotationVisitor { - override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { - return loadAnnotationIfNotSpecial(classId, result) + override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + return loadAnnotationIfNotSpecial(classId, source, result) } override fun visitEnd() { @@ -220,22 +223,24 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader() memberAnnotations[paramSignature] = result } - return loadAnnotationIfNotSpecial(classId, result) + return loadAnnotationIfNotSpecial(classId, source, result) } } open inner class MemberAnnotationVisitor(protected val signature: MemberSignature) : KotlinJvmBinaryClass.AnnotationVisitor { private val result = ArrayList() - override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { - return loadAnnotationIfNotSpecial(classId, result) + override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + return loadAnnotationIfNotSpecial(classId, source, result) } override fun visitEnd() { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt index 53470c8bac8..9e67dd01fab 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/BinaryClassAnnotationAndConstantLoaderImpl.kt @@ -16,10 +16,7 @@ package org.jetbrains.kotlin.load.kotlin -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils @@ -86,6 +83,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl( override fun loadAnnotation( annotationClassId: ClassId, + source: SourceElement, result: MutableList ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { val annotationClass = resolveClass(annotationClassId) @@ -127,7 +125,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl( override fun visitAnnotation(name: Name, classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { val list = ArrayList() - val visitor = loadAnnotation(classId, list)!! + val visitor = loadAnnotation(classId, SourceElement.NO_SOURCE, list)!! return object: KotlinJvmBinaryClass.AnnotationArgumentVisitor by visitor { override fun visitEnd() { visitor.visitEnd() @@ -149,7 +147,7 @@ public class BinaryClassAnnotationAndConstantLoaderImpl( } override fun visitEnd() { - result.add(AnnotationDescriptorImpl(annotationClass.getDefaultType(), arguments)) + result.add(AnnotationDescriptorImpl(annotationClass.getDefaultType(), arguments, source)) } private fun createConstant(name: Name?, value: Any?): ConstantValue<*> { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmBinaryClass.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmBinaryClass.java index 6b15e0d6501..bb0ac876152 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmBinaryClass.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmBinaryClass.java @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.kotlin; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader; import org.jetbrains.kotlin.name.ClassId; import org.jetbrains.kotlin.name.Name; @@ -51,14 +52,14 @@ public interface KotlinJvmBinaryClass { interface AnnotationVisitor { @Nullable - AnnotationArgumentVisitor visitAnnotation(@NotNull ClassId classId); + AnnotationArgumentVisitor visitAnnotation(@NotNull ClassId classId, @NotNull SourceElement source); void visitEnd(); } interface MethodAnnotationVisitor extends AnnotationVisitor { @Nullable - AnnotationArgumentVisitor visitParameterAnnotation(int index, @NotNull ClassId classId); + AnnotationArgumentVisitor visitParameterAnnotation(int index, @NotNull ClassId classId, @NotNull SourceElement source); } interface AnnotationArgumentVisitor { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java index 1365f6a39b9..8e438bd86ec 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/header/ReadKotlinClassHeaderAnnotationVisitor.java @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.kotlin.header; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.load.java.AbiVersionUtil; import org.jetbrains.kotlin.name.ClassId; import org.jetbrains.kotlin.name.Name; @@ -88,7 +89,7 @@ public class ReadKotlinClassHeaderAnnotationVisitor implements AnnotationVisitor @Nullable @Override - public AnnotationArgumentVisitor visitAnnotation(@NotNull ClassId classId) { + public AnnotationArgumentVisitor visitAnnotation(@NotNull ClassId classId, @NotNull SourceElement source) { if (headerKind != null) { // Ignore all Kotlin annotations except the first found return null; diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectAnnotationSource.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectAnnotationSource.kt new file mode 100644 index 00000000000..ad57626d904 --- /dev/null +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectAnnotationSource.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2015 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.load.kotlin.reflect + +import org.jetbrains.kotlin.descriptors.SourceElement + +public class ReflectAnnotationSource(public val annotation: Annotation) : SourceElement diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt index cb5afe6dace..833f330ae3a 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt @@ -99,7 +99,7 @@ private object ReflectClassStructure { for ((parameterIndex, annotations) in method.getParameterAnnotations().withIndex()) { for (annotation in annotations) { val annotationType = annotation.annotationType() - visitor.visitParameterAnnotation(parameterIndex, annotationType.classId)?.let { + visitor.visitParameterAnnotation(parameterIndex, annotationType.classId, ReflectAnnotationSource(annotation))?.let { processAnnotationArguments(it, annotation, annotationType) } } @@ -130,7 +130,9 @@ private object ReflectClassStructure { for ((parameterIndex, annotations) in parameterAnnotations.withIndex()) { for (annotation in annotations) { val annotationType = annotation.annotationType() - visitor.visitParameterAnnotation(parameterIndex + shift, annotationType.classId)?.let { + visitor.visitParameterAnnotation( + parameterIndex + shift, annotationType.classId, ReflectAnnotationSource(annotation) + )?.let { processAnnotationArguments(it, annotation, annotationType) } } @@ -155,7 +157,7 @@ private object ReflectClassStructure { private fun processAnnotation(visitor: KotlinJvmBinaryClass.AnnotationVisitor, annotation: Annotation) { val annotationType = annotation.annotationType() - visitor.visitAnnotation(annotationType.classId)?.let { + visitor.visitAnnotation(annotationType.classId, ReflectAnnotationSource(annotation))?.let { processAnnotationArguments(it, annotation, annotationType) } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index c89d6c6701b..0a8b59de637 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -709,7 +709,7 @@ public class KotlinBuiltIns { @NotNull public AnnotationDescriptor createExtensionAnnotation() { return new AnnotationDescriptorImpl(getBuiltInClassByName("extension").getDefaultType(), - Collections.>emptyMap()); + Collections.>emptyMap(), SourceElement.NO_SOURCE); } private static boolean isTypeAnnotatedWithExtension(@NotNull JetType type) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java index f0a8e72179d..1ad538fee5b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.java @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.descriptors.annotations; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.ReadOnly; +import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.resolve.constants.ConstantValue; import org.jetbrains.kotlin.types.JetType; @@ -31,4 +32,7 @@ public interface AnnotationDescriptor { @NotNull @ReadOnly Map> getAllValueArguments(); + + @NotNull + SourceElement getSource(); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java index aca2732e1d6..c1d50318fa9 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.descriptors.annotations; import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.renderer.DescriptorRenderer; import org.jetbrains.kotlin.resolve.constants.ConstantValue; @@ -28,13 +29,16 @@ import java.util.Map; public class AnnotationDescriptorImpl implements AnnotationDescriptor { private final JetType annotationType; private final Map> valueArguments; + private final SourceElement source; public AnnotationDescriptorImpl( @NotNull JetType annotationType, - @NotNull Map> valueArguments + @NotNull Map> valueArguments, + @NotNull SourceElement source ) { this.annotationType = annotationType; this.valueArguments = Collections.unmodifiableMap(valueArguments); + this.source = source; } @Override @@ -49,6 +53,12 @@ public class AnnotationDescriptorImpl implements AnnotationDescriptor { return valueArguments; } + @Override + @NotNull + public SourceElement getSource() { + return source; + } + @Override public String toString() { return DescriptorRenderer.FQ_NAMES_IN_TYPES.renderAnnotation(this); diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt index 475a9e34f8b..ad93d6f9005 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/AnnotationDeserializer.kt @@ -17,10 +17,7 @@ package org.jetbrains.kotlin.serialization.deserialization import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl import org.jetbrains.kotlin.name.ClassId @@ -55,7 +52,7 @@ public class AnnotationDeserializer(private val module: ModuleDescriptor) { arguments.toMap() } - return AnnotationDescriptorImpl(annotationClass.getDefaultType(), arguments) + return AnnotationDescriptorImpl(annotationClass.getDefaultType(), arguments, SourceElement.NO_SOURCE) } private fun resolveArgument( diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt index cd5f547e377..b6f4a28a080 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderContext.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.idea.decompiler.stubBuilder +import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.load.kotlin.AbstractBinaryClassAnnotationAndConstantLoader import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass @@ -109,7 +110,9 @@ class AnnotationLoaderForStubBuilder( override fun loadConstant(desc: String, initializer: Any) = null - override fun loadAnnotation(annotationClassId: ClassId, result: MutableList): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + override fun loadAnnotation( + annotationClassId: ClassId, source: SourceElement, result: MutableList + ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { result.add(annotationClassId) return null }