diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 0164eca07e6..4a458d4ac60 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -61,6 +62,7 @@ public class InjectorForJavaDescriptorResolver { private final DescriptorDeserializers descriptorDeserializers; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final DescriptorDeserializersStorage descriptorDeserializersStorage; + private final ConstantDescriptorDeserializer constantDescriptorDeserializer; public InjectorForJavaDescriptorResolver( @NotNull Project project, @@ -85,6 +87,7 @@ public class InjectorForJavaDescriptorResolver { this.descriptorDeserializers = new DescriptorDeserializers(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); + this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); this.javaClassFinder.setProject(project); @@ -105,6 +108,7 @@ public class InjectorForJavaDescriptorResolver { deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager); descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); + descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); @@ -114,6 +118,11 @@ public class InjectorForJavaDescriptorResolver { descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver); descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter); + constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver); + constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); + constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); + constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + javaClassFinder.initialize(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 7bdc798dc77..1e562e0f172 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -101,6 +102,7 @@ public class InjectorForLazyResolveWithJava { private final DescriptorDeserializers descriptorDeserializers; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final DescriptorDeserializersStorage descriptorDeserializersStorage; + private final ConstantDescriptorDeserializer constantDescriptorDeserializer; public InjectorForLazyResolveWithJava( @NotNull Project project, @@ -147,6 +149,7 @@ public class InjectorForLazyResolveWithJava { this.descriptorDeserializers = new DescriptorDeserializers(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); + this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); @@ -224,6 +227,7 @@ public class InjectorForLazyResolveWithJava { deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager); descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); + descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); @@ -233,6 +237,11 @@ public class InjectorForLazyResolveWithJava { descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver); descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter); + constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver); + constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); + constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); + constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + javaClassFinder.initialize(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index c7163b5f8ce..02697b59311 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -65,6 +65,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -121,6 +122,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final DescriptorDeserializers descriptorDeserializers; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final DescriptorDeserializersStorage descriptorDeserializersStorage; + private final ConstantDescriptorDeserializer constantDescriptorDeserializer; public InjectorForTopDownAnalyzerForJvm( @NotNull Project project, @@ -177,6 +179,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.descriptorDeserializers = new DescriptorDeserializers(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager); + this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); @@ -299,6 +302,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly deserializedDescriptorResolver.setStorageManager(storageManager); descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); + descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); @@ -308,6 +312,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly descriptorDeserializersStorage.setClassResolver(javaDescriptorResolver); descriptorDeserializersStorage.setErrorReporter(traceBasedErrorReporter); + constantDescriptorDeserializer.setClassResolver(javaDescriptorResolver); + constantDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); + constantDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder); + constantDescriptorDeserializer.setStorage(descriptorDeserializersStorage); + javaClassFinder.initialize(); } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java new file mode 100644 index 00000000000..96b3c8b668c --- /dev/null +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java @@ -0,0 +1,49 @@ +/* + * 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.descriptors.serialization.descriptors; + +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.lang.descriptors.ClassOrPackageFragmentDescriptor; +import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; + +import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; + +public interface ConstantDeserializer { + ConstantDeserializer UNSUPPORTED = new ConstantDeserializer() { + @Nullable + @Override + public CompileTimeConstant loadPropertyConstant( + @NotNull ClassOrPackageFragmentDescriptor container, + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind + ) { + throw new UnsupportedOperationException("Constants are not supported"); + } + }; + + @Nullable + CompileTimeConstant loadPropertyConstant( + @NotNull ClassOrPackageFragmentDescriptor container, + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind + ); +} diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java index e890f7ea8d7..7e3b534cc62 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java @@ -25,11 +25,20 @@ public interface Deserializers { public AnnotationDeserializer getAnnotationDeserializer() { return AnnotationDeserializer.UNSUPPORTED; } + + @NotNull + @Override + public ConstantDeserializer getConstantDeserializer() { + return ConstantDeserializer.UNSUPPORTED; + } }; @NotNull AnnotationDeserializer getAnnotationDeserializer(); + @NotNull + ConstantDeserializer getConstantDeserializer(); + enum AnnotatedCallableKind { FUNCTION, PROPERTY, diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index d761dcd7a10..36a6d6b7cc0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -211,7 +211,7 @@ public class AnnotationDescriptorDeserializer extends BaseDescriptorDeserializer return Annotations.EMPTY; } - List annotations = storage.getMemberAnnotations().invoke(kotlinClass).get(signature); + List annotations = storage.getStorage().invoke(kotlinClass).getMemberAnnotations().get(signature); return annotations == null ? Annotations.EMPTY : new AnnotationsImpl(annotations); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java new file mode 100644 index 00000000000..f024166bfc5 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/ConstantDescriptorDeserializer.java @@ -0,0 +1,78 @@ +/* + * 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; + +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.ConstantDeserializer; +import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor; +import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; +import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; +import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; + +import javax.inject.Inject; + +import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; + +public class ConstantDescriptorDeserializer extends BaseDescriptorDeserializer implements ConstantDeserializer { + @Inject + @Override + public void setStorage(@NotNull DescriptorDeserializersStorage storage) { + this.storage = storage; + } + + @Inject + @Override + public void setClassResolver(@NotNull DependencyClassByQualifiedNameResolver classResolver) { + this.classResolver = classResolver; + } + + @Inject + @Override + public void setKotlinClassFinder(@NotNull KotlinClassFinder kotlinClassFinder) { + this.kotlinClassFinder = kotlinClassFinder; + } + + @Inject + @Override + public void setErrorReporter(@NotNull ErrorReporter errorReporter) { + this.errorReporter = errorReporter; + } + + @Nullable + @Override + public CompileTimeConstant loadPropertyConstant( + @NotNull ClassOrPackageFragmentDescriptor container, + @NotNull ProtoBuf.Callable proto, + @NotNull NameResolver nameResolver, + @NotNull AnnotatedCallableKind kind + ) { + MemberSignature signature = getCallableSignature(proto, nameResolver, kind); + if (signature == null) return null; + + KotlinJvmBinaryClass kotlinClass = findClassWithMemberAnnotations(container, proto, nameResolver, kind); + if (kotlinClass == null) { + errorReporter.reportAnnotationLoadingError("Kotlin class for loading property constant is not found: " + container, null); + return null; + } + + return storage.getStorage().invoke(kotlinClass).getPropertyConstants().get(signature); + } +} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java index 0000253a254..eec84302c3d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.kotlin; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; +import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer; import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers; import javax.inject.Inject; @@ -25,15 +26,27 @@ import javax.inject.Inject; public class DescriptorDeserializers implements Deserializers { private AnnotationDescriptorDeserializer annotationDescriptorDeserializer; + private ConstantDescriptorDeserializer constantDescriptorDeserializer; @Inject public void setAnnotationDescriptorDeserializer(AnnotationDescriptorDeserializer annotationDescriptorDeserializer) { this.annotationDescriptorDeserializer = annotationDescriptorDeserializer; } + @Inject + public void setConstantDescriptorDeserializer(ConstantDescriptorDeserializer constantDescriptorDeserializer) { + this.constantDescriptorDeserializer = constantDescriptorDeserializer; + } + @NotNull @Override public AnnotationDeserializer getAnnotationDeserializer() { return annotationDescriptorDeserializer; } + + @NotNull + @Override + public ConstantDeserializer getConstantDeserializer() { + return constantDescriptorDeserializer; + } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java index a695c65e73f..d5fd1890df4 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializersStorage.java @@ -20,9 +20,11 @@ import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; +import org.jetbrains.jet.lang.resolve.java.resolver.ResolverPackage; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; import org.jetbrains.jet.storage.MemoizedFunctionToNotNull; @@ -36,21 +38,21 @@ public class DescriptorDeserializersStorage { private DependencyClassByQualifiedNameResolver classResolver; private ErrorReporter errorReporter; - private final MemoizedFunctionToNotNull>> memberAnnotations; + private final MemoizedFunctionToNotNull storage; public DescriptorDeserializersStorage(@NotNull StorageManager storageManager) { - this.memberAnnotations = storageManager.createMemoizedFunction( - new Function1>>() { + this.storage = storageManager.createMemoizedFunction( + new Function1() { @NotNull @Override - public Map> invoke(@NotNull KotlinJvmBinaryClass kotlinClass) { + public Storage invoke(@NotNull KotlinJvmBinaryClass kotlinClass) { try { return loadMemberAnnotationsFromClass(kotlinClass); } catch (IOException e) { errorReporter.reportAnnotationLoadingError( "Error loading member annotations from Kotlin class: " + kotlinClass, e); - return Collections.emptyMap(); + return Storage.EMPTY; } } }); @@ -67,15 +69,14 @@ public class DescriptorDeserializersStorage { } @NotNull - public MemoizedFunctionToNotNull>> getMemberAnnotations() { - return memberAnnotations; + protected MemoizedFunctionToNotNull getStorage() { + return storage; } @NotNull - protected Map> loadMemberAnnotationsFromClass(@NotNull KotlinJvmBinaryClass kotlinClass) - throws IOException { - final Map> memberAnnotations = - new HashMap>(); + private Storage loadMemberAnnotationsFromClass(@NotNull KotlinJvmBinaryClass kotlinClass) throws IOException { + final Map> memberAnnotations = new HashMap>(); + final Map> propertyConstants = new HashMap>(); kotlinClass.loadMemberAnnotations(new KotlinJvmBinaryClass.MemberVisitor() { @Nullable @@ -131,7 +132,7 @@ public class DescriptorDeserializersStorage { } }); - return memberAnnotations; + return new 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 @@ -173,4 +174,30 @@ public class DescriptorDeserializersStorage { return signature; } } + + protected static class Storage { + private final Map> memberAnnotations; + private final Map> propertyConstants; + + 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; + } + } } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt index 8308713f286..165bd7403f5 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.KotlinClassFinder import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage +import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler { val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile) @@ -115,9 +116,21 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di annotationDeserializer.setStorage(deserializerStorage) } + private val constantDeserializer = ConstantDescriptorDeserializer(); + { + constantDeserializer.setClassResolver { + fqName -> + classes(fqName.toClassId()) + } + constantDeserializer.setKotlinClassFinder(localClassFinder) + constantDeserializer.setErrorReporter(LOGGING_REPORTER) + constantDeserializer.setStorage(deserializerStorage) + } + private val deserializers = DescriptorDeserializers(); { deserializers.setAnnotationDescriptorDeserializer(annotationDeserializer) + deserializers.setConstantDescriptorDeserializer(constantDeserializer) } private val descriptorFinder = object : DescriptorFinder {