From 09ff1128eacf4198331eed7ff8c0e460093df52d Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Thu, 27 Nov 2014 14:51:07 +0300 Subject: [PATCH] Convert AnnotationDescriptorLoader, ConstantDescriptorLoader and DescriptorLoadersStorage --- .../kotlin/AnnotationDescriptorLoader.kt | 310 +++++++----------- .../kotlin/ConstantDescriptorLoader.kt | 50 +-- .../kotlin/DescriptorLoadersStorage.kt | 245 ++++++-------- 3 files changed, 235 insertions(+), 370 deletions(-) diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.kt index 2f5dbc6c295..0484913c0e5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorLoader.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 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. @@ -14,223 +14,163 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.resolve.kotlin; +package org.jetbrains.jet.lang.resolve.kotlin -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf; -import org.jetbrains.jet.descriptors.serialization.NameResolver; -import org.jetbrains.jet.descriptors.serialization.ProtoBuf; -import org.jetbrains.jet.descriptors.serialization.SerializationPackage; -import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; -import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader; -import org.jetbrains.jet.descriptors.serialization.descriptors.ProtoContainer; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl; -import org.jetbrains.jet.lang.resolve.constants.*; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; -import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; -import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor; -import org.jetbrains.jet.lang.resolve.name.ClassId; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.ErrorUtils; +import org.jetbrains.jet.descriptors.serialization.JavaProtoBuf +import org.jetbrains.jet.descriptors.serialization.NameResolver +import org.jetbrains.jet.descriptors.serialization.ProtoBuf +import org.jetbrains.jet.descriptors.serialization.* +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationLoader +import org.jetbrains.jet.descriptors.serialization.descriptors.ProtoContainer +import org.jetbrains.jet.lang.descriptors.* +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptorImpl +import org.jetbrains.jet.lang.resolve.constants.* +import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames +import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils +import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter +import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor +import org.jetbrains.jet.lang.resolve.name.ClassId +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.lang.types.ErrorUtils -import java.util.*; +import java.util.* -import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorLoadersStorage.MemberSignature; -import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.javaClassIdToKotlinClassId; +import org.jetbrains.jet.lang.resolve.kotlin.DescriptorLoadersStorage.MemberSignature +import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.javaClassIdToKotlinClassId -public class AnnotationDescriptorLoader extends BaseDescriptorLoader implements AnnotationLoader { - private final ModuleDescriptor module; +public class AnnotationDescriptorLoader(private val module: ModuleDescriptor, storage: DescriptorLoadersStorage, kotlinClassFinder: KotlinClassFinder, errorReporter: ErrorReporter) : BaseDescriptorLoader(kotlinClassFinder, errorReporter, storage), AnnotationLoader { - public AnnotationDescriptorLoader( - @NotNull ModuleDescriptor module, - @NotNull DescriptorLoadersStorage storage, - @NotNull KotlinClassFinder kotlinClassFinder, - @NotNull ErrorReporter errorReporter - ) { - super(kotlinClassFinder, errorReporter, storage); - this.module = module; - } - - @NotNull - @Override - public List loadClassAnnotations( - @NotNull ProtoBuf.Class classProto, - @NotNull NameResolver nameResolver - ) { - ClassId classId = nameResolver.getClassId(classProto.getFqName()); - KotlinJvmBinaryClass kotlinClass = findKotlinClassById(classId); + override fun loadClassAnnotations(classProto: ProtoBuf.Class, nameResolver: NameResolver): List { + val classId = nameResolver.getClassId(classProto.getFqName()) + val kotlinClass = findKotlinClassById(classId) if (kotlinClass == null) { // This means that the resource we're constructing the descriptor from is no longer present: KotlinClassFinder had found the // class earlier, but it can't now - getErrorReporter().reportLoadingError("Kotlin class for loading class annotations is not found: " + classId.asSingleFqName(), null); - return Collections.emptyList(); + errorReporter.reportLoadingError("Kotlin class for loading class annotations is not found: " + classId.asSingleFqName(), null) + return listOf() } - final List result = new ArrayList(1); + val result = ArrayList(1) - kotlinClass.loadClassAnnotations(new KotlinJvmBinaryClass.AnnotationVisitor() { - @Nullable - @Override - public KotlinJvmBinaryClass.AnnotationArgumentVisitor visitAnnotation(@NotNull ClassId classId) { - return resolveAnnotation(classId, result, module); + kotlinClass.loadClassAnnotations(object : KotlinJvmBinaryClass.AnnotationVisitor { + override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + return resolveAnnotation(classId, result, module) } - @Override - public void visitEnd() { + override fun visitEnd() { } - }); + }) - return result; + return result } - @Nullable - public static KotlinJvmBinaryClass.AnnotationArgumentVisitor resolveAnnotation( - @NotNull ClassId classId, - @NotNull final List result, - @NotNull final ModuleDescriptor moduleDescriptor - ) { - if (JvmAnnotationNames.isSpecialAnnotation(classId, true)) return null; + override fun loadCallableAnnotations(container: ProtoContainer, proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind): List { + val signature = getCallableSignature(proto, nameResolver, kind) + if (signature == null) return listOf() - final ClassDescriptor annotationClass = resolveClass(classId, moduleDescriptor); + return findClassAndLoadMemberAnnotations(container, proto, nameResolver, kind, signature) + } - return new KotlinJvmBinaryClass.AnnotationArgumentVisitor() { - private final Map> arguments = new HashMap>(); + private fun findClassAndLoadMemberAnnotations(container: ProtoContainer, proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind, signature: MemberSignature): List { + val kotlinClass = findClassWithAnnotationsAndInitializers(container, proto, nameResolver, kind) + if (kotlinClass == null) { + errorReporter.reportLoadingError("Kotlin class for loading member annotations is not found: " + container, null) + return listOf() + } - @Override - public void visit(@Nullable Name name, @Nullable Object value) { - if (name != null) { - setArgumentValueByName(name, createConstant(name, value)); + val descriptors = storage.getStorageForClass(kotlinClass).memberAnnotations.get(signature) + return if (descriptors == null) listOf() else descriptors + } + + override fun loadValueParameterAnnotations(container: ProtoContainer, callable: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind, proto: ProtoBuf.Callable.ValueParameter): List { + val methodSignature = getCallableSignature(callable, nameResolver, kind) + if (methodSignature != null) { + if (proto.hasExtension(JavaProtoBuf.index)) { + val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, proto.getExtension(JavaProtoBuf.index)) + return findClassAndLoadMemberAnnotations(container, callable, nameResolver, kind, paramSignature) + } + } + + return listOf() + } + + class object { + + public fun resolveAnnotation(classId: ClassId, result: MutableList, moduleDescriptor: ModuleDescriptor): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + if (JvmAnnotationNames.isSpecialAnnotation(classId, true)) return null + + val annotationClass = resolveClass(classId, moduleDescriptor) + + return object : KotlinJvmBinaryClass.AnnotationArgumentVisitor { + private val arguments = HashMap>() + + override fun visit(name: Name?, value: Any?) { + if (name != null) { + setArgumentValueByName(name, createConstant(name, value)) + } } - } - @Override - public void visitEnum(@NotNull Name name, @NotNull ClassId enumClassId, @NotNull Name enumEntryName) { - setArgumentValueByName(name, enumEntryValue(enumClassId, enumEntryName)); - } + override fun visitEnum(name: Name, enumClassId: ClassId, enumEntryName: Name) { + setArgumentValueByName(name, enumEntryValue(enumClassId, enumEntryName)) + } - @Nullable - @Override - public AnnotationArrayArgumentVisitor visitArray(@NotNull final Name name) { - return new KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor() { - private final ArrayList> elements = new ArrayList>(); + override fun visitArray(name: Name): AnnotationArrayArgumentVisitor? { + return object : KotlinJvmBinaryClass.AnnotationArrayArgumentVisitor { + private val elements = ArrayList>() - @Override - public void visit(@Nullable Object value) { - elements.add(createConstant(name, value)); - } + override fun visit(value: Any?) { + elements.add(createConstant(name, value)) + } - @Override - public void visitEnum(@NotNull ClassId enumClassId, @NotNull Name enumEntryName) { - elements.add(enumEntryValue(enumClassId, enumEntryName)); - } + override fun visitEnum(enumClassId: ClassId, enumEntryName: Name) { + elements.add(enumEntryValue(enumClassId, enumEntryName)) + } - @Override - public void visitEnd() { - ValueParameterDescriptor parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass); - if (parameter != null) { - elements.trimToSize(); - arguments.put(parameter, new ArrayValue(elements, parameter.getType(), true, false)); + override fun visitEnd() { + val parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass) + if (parameter != null) { + elements.trimToSize() + arguments.put(parameter, ArrayValue(elements, parameter.getType(), true, false)) + } } } - }; - } + } - @NotNull - private CompileTimeConstant enumEntryValue(@NotNull ClassId enumClassId, @NotNull Name name) { - ClassDescriptor enumClass = resolveClass(enumClassId, moduleDescriptor); - if (enumClass.getKind() == ClassKind.ENUM_CLASS) { - ClassifierDescriptor classifier = enumClass.getUnsubstitutedInnerClassesScope().getClassifier(name); - if (classifier instanceof ClassDescriptor) { - return new EnumValue((ClassDescriptor) classifier, false); + private fun enumEntryValue(enumClassId: ClassId, name: Name): CompileTimeConstant<*> { + val enumClass = resolveClass(enumClassId, moduleDescriptor) + if (enumClass.getKind() == ClassKind.ENUM_CLASS) { + val classifier = enumClass.getUnsubstitutedInnerClassesScope().getClassifier(name) + if (classifier is ClassDescriptor) { + return EnumValue(classifier as ClassDescriptor, false) + } + } + return ErrorValue.create("Unresolved enum entry: " + enumClassId + "." + name) + } + + override fun visitEnd() { + result.add(AnnotationDescriptorImpl(annotationClass.getDefaultType(), arguments)) + } + + private fun createConstant(name: Name?, value: Any?): CompileTimeConstant<*> { + val argument = createCompileTimeConstant(value, true, false, false, null) + return if (argument != null) argument else ErrorValue.create("Unsupported annotation argument: " + name) + } + + private fun setArgumentValueByName(name: Name, argumentValue: CompileTimeConstant<*>) { + val parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass) + if (parameter != null) { + arguments.put(parameter, argumentValue) } } - return ErrorValue.create("Unresolved enum entry: " + enumClassId + "." + name); - } - - @Override - public void visitEnd() { - result.add(new AnnotationDescriptorImpl( - annotationClass.getDefaultType(), - arguments - )); - } - - @NotNull - private CompileTimeConstant createConstant(@Nullable Name name, @Nullable Object value) { - CompileTimeConstant argument = ConstantsPackage.createCompileTimeConstant(value, true, false, false, null); - return argument != null ? argument : ErrorValue.create("Unsupported annotation argument: " + name); - } - - private void setArgumentValueByName(@NotNull Name name, @NotNull CompileTimeConstant argumentValue) { - ValueParameterDescriptor parameter = DescriptorResolverUtils.getAnnotationParameterByName(name, annotationClass); - if (parameter != null) { - arguments.put(parameter, argumentValue); - } - } - }; - } - - @NotNull - private static ClassDescriptor resolveClass(@NotNull ClassId javaClassId, @NotNull ModuleDescriptor moduleDescriptor) { - ClassId classId = javaClassIdToKotlinClassId(javaClassId); - ClassDescriptor classDescriptor = SerializationPackage.findClassAcrossModuleDependencies(moduleDescriptor, classId); - return classDescriptor != null ? classDescriptor : ErrorUtils.createErrorClass(classId.asSingleFqName().asString()); - } - - @NotNull - @Override - public List loadCallableAnnotations( - @NotNull ProtoContainer container, - @NotNull ProtoBuf.Callable proto, - @NotNull NameResolver nameResolver, - @NotNull AnnotatedCallableKind kind - ) { - MemberSignature signature = getCallableSignature(proto, nameResolver, kind); - if (signature == null) return Collections.emptyList(); - - return findClassAndLoadMemberAnnotations(container, proto, nameResolver, kind, signature); - } - - @NotNull - private List findClassAndLoadMemberAnnotations( - @NotNull ProtoContainer container, - @NotNull ProtoBuf.Callable proto, - @NotNull NameResolver nameResolver, - @NotNull AnnotatedCallableKind kind, - @NotNull MemberSignature signature - ) { - KotlinJvmBinaryClass kotlinClass = findClassWithAnnotationsAndInitializers(container, proto, nameResolver, kind); - if (kotlinClass == null) { - getErrorReporter().reportLoadingError("Kotlin class for loading member annotations is not found: " + container, null); - return Collections.emptyList(); - } - - List descriptors = getStorage().getStorageForClass(kotlinClass).getMemberAnnotations().get(signature); - return descriptors == null ? Collections.emptyList() : descriptors; - } - - @NotNull - @Override - public List loadValueParameterAnnotations( - @NotNull ProtoContainer container, - @NotNull ProtoBuf.Callable callable, - @NotNull NameResolver nameResolver, - @NotNull AnnotatedCallableKind kind, - @NotNull ProtoBuf.Callable.ValueParameter proto - ) { - MemberSignature methodSignature = getCallableSignature(callable, nameResolver, kind); - if (methodSignature != null) { - if (proto.hasExtension(JavaProtoBuf.index)) { - MemberSignature paramSignature = - MemberSignature.fromMethodSignatureAndParameterIndex(methodSignature, proto.getExtension(JavaProtoBuf.index)); - return findClassAndLoadMemberAnnotations(container, callable, nameResolver, kind, paramSignature); } } - return Collections.emptyList(); + private fun resolveClass(javaClassId: ClassId, moduleDescriptor: ModuleDescriptor): ClassDescriptor { + val classId = javaClassIdToKotlinClassId(javaClassId) + val classDescriptor = moduleDescriptor.findClassAcrossModuleDependencies(classId) + return if (classDescriptor != null) classDescriptor else ErrorUtils.createErrorClass(classId.asSingleFqName().asString()) + } } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.kt index 704d404da15..89022b947ac 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorLoader.kt @@ -14,46 +14,30 @@ * limitations under the License. */ -package org.jetbrains.jet.lang.resolve.kotlin; +package org.jetbrains.jet.lang.resolve.kotlin -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.NameResolver; -import org.jetbrains.jet.descriptors.serialization.ProtoBuf; -import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; -import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader; -import org.jetbrains.jet.descriptors.serialization.descriptors.ProtoContainer; -import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; +import org.jetbrains.jet.descriptors.serialization.NameResolver +import org.jetbrains.jet.descriptors.serialization.ProtoBuf +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind +import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader +import org.jetbrains.jet.descriptors.serialization.descriptors.ProtoContainer +import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant +import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter -import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorLoadersStorage.MemberSignature; +import org.jetbrains.jet.lang.resolve.kotlin.DescriptorLoadersStorage.MemberSignature -public class ConstantDescriptorLoader extends BaseDescriptorLoader implements ConstantLoader { - public ConstantDescriptorLoader( - @NotNull DescriptorLoadersStorage storage, - @NotNull KotlinClassFinder kotlinClassFinder, - @NotNull ErrorReporter errorReporter - ) { - super(kotlinClassFinder, errorReporter, storage); - } +public class ConstantDescriptorLoader(storage: DescriptorLoadersStorage, kotlinClassFinder: KotlinClassFinder, errorReporter: ErrorReporter) : BaseDescriptorLoader(kotlinClassFinder, errorReporter, storage), ConstantLoader { - @Nullable - @Override - public CompileTimeConstant loadPropertyConstant( - @NotNull ProtoContainer container, - @NotNull ProtoBuf.Callable proto, - @NotNull NameResolver nameResolver, - @NotNull AnnotatedCallableKind kind - ) { - MemberSignature signature = getCallableSignature(proto, nameResolver, kind); - if (signature == null) return null; + override fun loadPropertyConstant(container: ProtoContainer, proto: ProtoBuf.Callable, nameResolver: NameResolver, kind: AnnotatedCallableKind): CompileTimeConstant<*>? { + val signature = getCallableSignature(proto, nameResolver, kind) + if (signature == null) return null - KotlinJvmBinaryClass kotlinClass = findClassWithAnnotationsAndInitializers(container, proto, nameResolver, kind); + val kotlinClass = findClassWithAnnotationsAndInitializers(container, proto, nameResolver, kind) if (kotlinClass == null) { - getErrorReporter().reportLoadingError("Kotlin class for loading property constant is not found: " + container, null); - return null; + errorReporter.reportLoadingError("Kotlin class for loading property constant is not found: " + container, null) + return null } - return getStorage().getStorageForClass(kotlinClass).getPropertyConstants().get(signature); + return storage.getStorageForClass(kotlinClass).propertyConstants.get(signature) } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorLoadersStorage.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorLoadersStorage.kt index eb8eb762c1b..c943b0fb932 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorLoadersStorage.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorLoadersStorage.kt @@ -1,216 +1,157 @@ /* -* Copyright 2010-2014 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. -*/ + * Copyright 2010-2014 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.jet.lang.resolve.kotlin; +package org.jetbrains.jet.lang.resolve.kotlin -import kotlin.Function1; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.resolve.constants.ConstantsPackage; -import org.jetbrains.jet.lang.resolve.name.ClassId; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; -import org.jetbrains.jet.storage.StorageManager; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.jet.lang.resolve.constants.* +import org.jetbrains.jet.lang.resolve.name.ClassId +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.storage.MemoizedFunctionToNotNull +import org.jetbrains.jet.storage.StorageManager -import java.util.*; +import java.util.* +import kotlin.platform.platformStatic -public class DescriptorLoadersStorage { - private final MemoizedFunctionToNotNull storage; - private final ModuleDescriptor module; +public class DescriptorLoadersStorage(storageManager: StorageManager, private val module: ModuleDescriptor) { + private val storage: MemoizedFunctionToNotNull - public DescriptorLoadersStorage(@NotNull StorageManager storageManager, @NotNull ModuleDescriptor module) { - this.storage = storageManager.createMemoizedFunction( - new Function1() { - @NotNull - @Override - public Storage invoke(@NotNull KotlinJvmBinaryClass kotlinClass) { - return loadAnnotationsAndInitializers(kotlinClass); - } - } - ); - this.module = module; + { + this.storage = storageManager.createMemoizedFunction(object : Function1 { + override fun invoke(kotlinClass: KotlinJvmBinaryClass): Storage { + return loadAnnotationsAndInitializers(kotlinClass) + } + }) } - @NotNull - protected Storage getStorageForClass(@NotNull KotlinJvmBinaryClass kotlinClass) { - return storage.invoke(kotlinClass); + public fun getStorageForClass(kotlinClass: KotlinJvmBinaryClass): Storage { + return storage.invoke(kotlinClass) } - @NotNull - private Storage loadAnnotationsAndInitializers(@NotNull KotlinJvmBinaryClass kotlinClass) { - final Map> memberAnnotations = new HashMap>(); - final Map> propertyConstants = new HashMap>(); + private fun loadAnnotationsAndInitializers(kotlinClass: KotlinJvmBinaryClass): Storage { + val memberAnnotations = HashMap>() + val propertyConstants = HashMap>() - kotlinClass.visitMembers(new KotlinJvmBinaryClass.MemberVisitor() { - @Nullable - @Override - public KotlinJvmBinaryClass.MethodAnnotationVisitor visitMethod(@NotNull Name name, @NotNull String desc) { - return new AnnotationVisitorForMethod(MemberSignature.fromMethodNameAndDesc(name.asString() + desc)); + kotlinClass.visitMembers(object : KotlinJvmBinaryClass.MemberVisitor { + override fun visitMethod(name: Name, desc: String): KotlinJvmBinaryClass.MethodAnnotationVisitor? { + return AnnotationVisitorForMethod(MemberSignature.fromMethodNameAndDesc(name.asString() + desc)) } - @Nullable - @Override - public KotlinJvmBinaryClass.AnnotationVisitor visitField(@NotNull Name name, @NotNull String desc, @Nullable Object initializer) { - MemberSignature signature = MemberSignature.fromFieldNameAndDesc(name, desc); + override fun visitField(name: Name, desc: String, initializer: Any?): KotlinJvmBinaryClass.AnnotationVisitor? { + val signature = MemberSignature.fromFieldNameAndDesc(name, desc) if (initializer != null) { - Object normalizedValue; + val normalizedValue: Any if ("ZBCS".contains(desc)) { - int intValue = ((Integer) initializer).intValue(); - if ("Z".equals(desc)) { - normalizedValue = intValue != 0; + val intValue = initializer as Int + if ("Z" == desc) { + normalizedValue = intValue != 0 } - else if ("B".equals(desc)) { - normalizedValue = ((byte) intValue); + else if ("B" == desc) { + normalizedValue = (intValue.toByte()) } - else if ("C".equals(desc)) { - normalizedValue = ((char) intValue); + else if ("C" == desc) { + normalizedValue = (intValue.toChar()) } - else if ("S".equals(desc)) { - normalizedValue = ((short) intValue); + else if ("S" == desc) { + normalizedValue = (intValue.toShort()) } else { - throw new AssertionError(desc); + throw AssertionError(desc) } } else { - normalizedValue = initializer; + normalizedValue = initializer } - propertyConstants.put(signature, ConstantsPackage.createCompileTimeConstant( - normalizedValue, - /* canBeUsedInAnnotation */ true, - /* isPureIntConstant */ true, - /* usesVariableAsConstant */ true, - /* expectedType */ null - )); + propertyConstants.put(signature, createCompileTimeConstant(normalizedValue, /* canBeUsedInAnnotation */ true, /* isPureIntConstant */ true, /* usesVariableAsConstant */ true, /* expectedType */ null)) } - return new MemberAnnotationVisitor(signature); + return MemberAnnotationVisitor(signature) } - class AnnotationVisitorForMethod extends MemberAnnotationVisitor implements KotlinJvmBinaryClass.MethodAnnotationVisitor { - public AnnotationVisitorForMethod(@NotNull MemberSignature signature) { - super(signature); - } + inner class AnnotationVisitorForMethod(signature: MemberSignature) : MemberAnnotationVisitor(signature), KotlinJvmBinaryClass.MethodAnnotationVisitor { - @Nullable - @Override - public KotlinJvmBinaryClass.AnnotationArgumentVisitor visitParameterAnnotation(int index, @NotNull ClassId classId) { - MemberSignature paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(signature, index); - List result = memberAnnotations.get(paramSignature); + override fun visitParameterAnnotation(index: Int, classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + val paramSignature = MemberSignature.fromMethodSignatureAndParameterIndex(signature, index) + var result = memberAnnotations.get(paramSignature) if (result == null) { - result = new ArrayList(); - memberAnnotations.put(paramSignature, result); + result = ArrayList() + memberAnnotations.put(paramSignature, result) } - return AnnotationDescriptorLoader.resolveAnnotation(classId, result, module); + return AnnotationDescriptorLoader.resolveAnnotation(classId, result, module) } } - class MemberAnnotationVisitor implements KotlinJvmBinaryClass.AnnotationVisitor { - private final List result = new ArrayList(); - protected final MemberSignature signature; + open inner class MemberAnnotationVisitor(protected val signature: MemberSignature) : KotlinJvmBinaryClass.AnnotationVisitor { + private val result = ArrayList() - public MemberAnnotationVisitor(@NotNull MemberSignature signature) { - this.signature = signature; + override fun visitAnnotation(classId: ClassId): KotlinJvmBinaryClass.AnnotationArgumentVisitor? { + return AnnotationDescriptorLoader.resolveAnnotation(classId, result, module) } - @Nullable - @Override - public KotlinJvmBinaryClass.AnnotationArgumentVisitor visitAnnotation(@NotNull ClassId classId) { - return AnnotationDescriptorLoader.resolveAnnotation(classId, result, module); - } - - @Override - public void visitEnd() { + override fun visitEnd() { if (!result.isEmpty()) { - memberAnnotations.put(signature, result); + memberAnnotations.put(signature, result) } } } - }); + }) - return new Storage(memberAnnotations, propertyConstants); + return Storage(memberAnnotations, propertyConstants) } // The purpose of this class is to hold a unique signature of either a method or a field, so that annotations on a member can be put // into a map indexed by these signatures - public static final class MemberSignature { - private final String signature; + public class MemberSignature private(private val signature: String) { - private MemberSignature(@NotNull String signature) { - this.signature = signature; + override fun hashCode(): Int { + return signature.hashCode() } - @NotNull - public static MemberSignature fromMethodNameAndDesc(@NotNull String nameAndDesc) { - return new MemberSignature(nameAndDesc); + override fun equals(o: Any?): Boolean { + return o is MemberSignature && signature == (o as MemberSignature).signature } - @NotNull - public static MemberSignature fromFieldNameAndDesc(@NotNull Name name, @NotNull String desc) { - return new MemberSignature(name.asString() + "#" + desc); + override fun toString(): String { + return signature } - @NotNull - public static MemberSignature fromMethodSignatureAndParameterIndex(@NotNull MemberSignature signature, int index) { - return new MemberSignature(signature.signature + "@" + index); - } + class object { - @Override - public int hashCode() { - return signature.hashCode(); - } + platformStatic public fun fromMethodNameAndDesc(nameAndDesc: String): MemberSignature { + return MemberSignature(nameAndDesc) + } - @Override - public boolean equals(Object o) { - return o instanceof MemberSignature && signature.equals(((MemberSignature) o).signature); - } + platformStatic public fun fromFieldNameAndDesc(name: Name, desc: String): MemberSignature { + return MemberSignature(name.asString() + "#" + desc) + } - @Override - public String toString() { - return signature; + platformStatic public fun fromMethodSignatureAndParameterIndex(signature: MemberSignature, index: Int): MemberSignature { + return MemberSignature(signature.signature + "@" + index) + } } } - protected static class Storage { - private final Map> memberAnnotations; - private final Map> propertyConstants; + class Storage( + public val memberAnnotations: Map>, + public val propertyConstants: Map>) { + class object { - public static final Storage EMPTY = new Storage( - Collections.>emptyMap(), - Collections.>emptyMap() - ); - - public Storage( - @NotNull Map> annotations, - @NotNull Map> constants - ) { - this.memberAnnotations = annotations; - this.propertyConstants = constants; - } - - public Map> getMemberAnnotations() { - return memberAnnotations; - } - - public Map> getPropertyConstants() { - return propertyConstants; + public val EMPTY: Storage = Storage(mapOf>(), mapOf>()) } } }