Add SourceElement to AnnotationDescriptor

Use KotlinSourceElement in the compiler for annotations resolved from PSI,
introduce ReflectAnnotationSource for reflection

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);
                     }
 

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.*
-import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
 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()
             }

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<ValueParameterDescriptor, ConstantValue<*>> {
@@ -121,6 +127,8 @@ public class LazyAnnotationDescriptor(
                 .filterValues { it != null } as Map<ValueParameterDescriptor, ConstantValue<*>>
     }
 
+    override fun getSource() = source
+
     override fun forceResolveAllContents() {
         ForceResolveUtil.forceResolveAllContents(getType())
         getAllValueArguments()

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.*
-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.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<ValueParameterDescriptor>
             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) {

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<ValueParameterDescriptor, ConstantValue<*>> {
         val constructors = getAnnotationClass().getConstructors()
         if (constructors.isEmpty()) return mapOf()

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]"
 }

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<A : Any, C
 
     protected abstract fun loadAnnotation(
             annotationClassId: ClassId,
+            source: SourceElement,
             result: MutableList<A>
     ): KotlinJvmBinaryClass.AnnotationArgumentVisitor?
 
@@ -54,11 +56,12 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
 
     private fun loadAnnotationIfNotSpecial(
             annotationClassId: ClassId,
+            source: SourceElement,
             result: MutableList<A>
     ): 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<A> {
@@ -74,8 +77,8 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
         val result = ArrayList<A>(1)
 
         kotlinClass.loadClassAnnotations(object : KotlinJvmBinaryClass.AnnotationVisitor {
-            override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
+            override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
-                return loadAnnotationIfNotSpecial(classId, result)
+                return loadAnnotationIfNotSpecial(classId, source, result)
             }
 
             override fun visitEnd() {
@@ -220,22 +223,24 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader<A : Any, C
 
             inner class AnnotationVisitorForMethod(signature: MemberSignature) : MemberAnnotationVisitor(signature), KotlinJvmBinaryClass.MethodAnnotationVisitor {
 
-                override fun visitParameterAnnotation(index: Int, classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
+                override fun visitParameterAnnotation(
+                        index: Int, classId: ClassId, source: SourceElement
+                ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
                     val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(signature, index)
                     var result = memberAnnotations[paramSignature]
                     if (result == null) {
                         result = ArrayList<A>()
                         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<A>()
 
-                override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
+                override fun visitAnnotation(classId: ClassId, source: SourceElement): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
-                    return loadAnnotationIfNotSpecial(classId, result)
+                    return loadAnnotationIfNotSpecial(classId, source, result)
                 }
 
                 override fun visitEnd() {

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.*
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 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<AnnotationDescriptor>
     ): 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<AnnotationDescriptor>()
-                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<*> {

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 {

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;

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

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)
         }
     }

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.<ValueParameterDescriptor, ConstantValue<?>>emptyMap());
+                                            Collections.<ValueParameterDescriptor, ConstantValue<?>>emptyMap(), SourceElement.NO_SOURCE);
     }
 
     private static boolean isTypeAnnotatedWithExtension(@NotNull JetType type) {

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<ValueParameterDescriptor, ConstantValue<?>> getAllValueArguments();
+
+    @NotNull
+    SourceElement getSource();
 }

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<ValueParameterDescriptor, ConstantValue<?>> valueArguments;
+    private final SourceElement source;
 
     public AnnotationDescriptorImpl(
             @NotNull JetType annotationType,
-            @NotNull Map<ValueParameterDescriptor, ConstantValue<?>> valueArguments
+            @NotNull Map<ValueParameterDescriptor, ConstantValue<?>> 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);

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.*
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 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(

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<ClassId>): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
+    override fun loadAnnotation(
+            annotationClassId: ClassId, source: SourceElement, result: MutableList<ClassId>
+    ): KotlinJvmBinaryClass.AnnotationArgumentVisitor? {
         result.add(annotationClassId)
         return null
     }