Use lazy to store split annotations, code simplification

compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java

@@ -40,7 +40,6 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 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.JetType;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationSplitter;
@@ -119,7 +118,7 @@ public class PropertyCodegen {
 
             boolean hasBackingField = hasBackingField(declaration, descriptor);
 
-            AnnotationSplitter annotationSplitter = AnnotationSplitter.create(LockBasedStorageManager.NO_LOCKS,
+            AnnotationSplitter annotationSplitter = AnnotationSplitter.create(
                     descriptor.getAnnotations(), AnnotationSplitter.getTargetSet(false, descriptor.isVar(), hasBackingField));
 
             Annotations fieldAnnotations = annotationSplitter.getAnnotationsForTarget(AnnotationUseSiteTarget.FIELD);
@@ -172,7 +171,7 @@ public class PropertyCodegen {
     }
 
     public void generatePrimaryConstructorProperty(JetParameter p, PropertyDescriptor descriptor) {
-        AnnotationSplitter annotationSplitter = AnnotationSplitter.create(LockBasedStorageManager.NO_LOCKS,
+        AnnotationSplitter annotationSplitter = AnnotationSplitter.create(
                 descriptor.getAnnotations(), AnnotationSplitter.getTargetSet(true, descriptor.isVar(), hasBackingField(p, descriptor)));
 
         Annotations fieldAnnotations = annotationSplitter.getAnnotationsForTarget(AnnotationUseSiteTarget.FIELD);

compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt

@@ -36,29 +36,20 @@ import org.jetbrains.kotlin.storage.StorageManager
              other -> [T].
  */
 
-public class AnnotationSplitter(
-        storageManager: StorageManager,
-        allAnnotations: Annotations,
-        applicableTargetsLazy: () -> Set<AnnotationUseSiteTarget>
-) {
+public class AnnotationSplitter(allAnnotations: Annotations, applicableTargetsLazy: () -> Set<AnnotationUseSiteTarget>) {
     public companion object {
         private val TARGET_PRIORITIES = setOf(CONSTRUCTOR_PARAMETER, FIELD, PROPERTY, PROPERTY_SETTER, PROPERTY_GETTER)
 
         @jvmStatic
-        public fun create(
-                storageManager: StorageManager,
-                annotations: Annotations,
-                targets: Set<AnnotationUseSiteTarget>
-        ): AnnotationSplitter {
-            return AnnotationSplitter(storageManager, annotations, { targets })
+        public fun create(annotations: Annotations, targets: Set<AnnotationUseSiteTarget>): AnnotationSplitter {
+            return AnnotationSplitter(annotations, { targets })
         }
 
         @jvmStatic
         public fun getTargetSet(parameter: Boolean, context: BindingContext, wrapper: PropertyWrapper): Set<AnnotationUseSiteTarget> {
-            val property = wrapper.property
-            assert(property != null)
+            val property = wrapper.property!!
             val hasBackingField = context[BindingContext.BACKING_FIELD_REQUIRED, property] ?: false
-            return getTargetSet(parameter, property!!.isVar, hasBackingField)
+            return getTargetSet(parameter, property.isVar, hasBackingField)
         }
 
         @jvmStatic
@@ -73,7 +64,7 @@ public class AnnotationSplitter(
 
     public class PropertyWrapper(public var property: PropertyDescriptor? = null)
 
-    private val splitAnnotations = storageManager.createLazyValue {
+    private val splitAnnotations by lazy {
         val map = hashMapOf<AnnotationUseSiteTarget, MutableList<AnnotationWithTarget>>()
         val other = arrayListOf<AnnotationWithTarget>()
         val applicableTargets = applicableTargetsLazy()
@@ -116,7 +107,7 @@ public class AnnotationSplitter(
 
     private inner class LazySplitAnnotations(target: AnnotationUseSiteTarget?) : Annotations {
         private val annotations: Annotations by lazy {
-            val splitAnnotations = this@AnnotationSplitter.splitAnnotations()
+            val splitAnnotations = this@AnnotationSplitter.splitAnnotations
 
             if (target != null)
                 AnnotationsImpl.create(splitAnnotations.first[target] ?: emptyList())

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -343,7 +343,7 @@ public class DescriptorResolver {
         if (modifierList != null) {
             if (valueParameter.hasValOrVar()) {
                 AnnotationSplitter annotationSplitter = AnnotationSplitter.create(
-                        storageManager, allAnnotations, KotlinPackage.setOf(CONSTRUCTOR_PARAMETER));
+                        allAnnotations, KotlinPackage.setOf(CONSTRUCTOR_PARAMETER));
                 valueParameterAnnotations = annotationSplitter.getAnnotationsForTarget(CONSTRUCTOR_PARAMETER);
             }
             else {
@@ -718,8 +718,7 @@ public class DescriptorResolver {
         final AnnotationSplitter.PropertyWrapper wrapper = new AnnotationSplitter.PropertyWrapper();
 
         Annotations allAnnotations = annotationResolver.resolveAnnotationsWithoutArguments(scope, modifierList, trace);
-        AnnotationSplitter annotationSplitter =
-                new AnnotationSplitter(storageManager, allAnnotations, new Function0<Set<AnnotationUseSiteTarget>>() {
+        AnnotationSplitter annotationSplitter = new AnnotationSplitter(allAnnotations, new Function0<Set<AnnotationUseSiteTarget>>() {
             @Override
             public Set<AnnotationUseSiteTarget> invoke() {
                 return AnnotationSplitter.getTargetSet(false, trace.getBindingContext(), wrapper);
@@ -1077,7 +1076,8 @@ public class DescriptorResolver {
             @NotNull ClassDescriptor classDescriptor,
             @NotNull ValueParameterDescriptor valueParameter,
             @NotNull LexicalScope scope,
-            @NotNull JetParameter parameter, BindingTrace trace
+            @NotNull JetParameter parameter,
+            final BindingTrace trace
     ) {
         JetType type = resolveParameterType(scope, parameter, trace);
         Name name = parameter.getNameAsSafeName();
@@ -1092,13 +1092,12 @@ public class DescriptorResolver {
 
         final AnnotationSplitter.PropertyWrapper propertyWrapper = new AnnotationSplitter.PropertyWrapper();
         Annotations allAnnotations = annotationResolver.resolveAnnotationsWithoutArguments(scope, parameter.getModifierList(), trace);
-        AnnotationSplitter annotationSplitter =
-                new AnnotationSplitter(storageManager, allAnnotations, new Function0<Set<AnnotationUseSiteTarget>>() {
-                    @Override
-                    public Set<AnnotationUseSiteTarget> invoke() {
-                        return AnnotationSplitter.getTargetSet(true, trace.getBindingContext(), propertyWrapper);
-                    }
-                });
+        AnnotationSplitter annotationSplitter = new AnnotationSplitter(allAnnotations, new Function0<Set<AnnotationUseSiteTarget>>() {
+            @Override
+            public Set<AnnotationUseSiteTarget> invoke() {
+                return AnnotationSplitter.getTargetSet(true, trace.getBindingContext(), propertyWrapper);
+            }
+        });
 
         Annotations propertyAnnotations = new CompositeAnnotations(
                 annotationSplitter.getAnnotationsForTargets(PROPERTY, FIELD),