From b9b0bba7a0879e8575ead6634d676940f3c46e88 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 16 Jun 2014 17:32:47 +0400 Subject: [PATCH] Refactor: Introduce contexts in deserialization subsystem Rewrite utilities to Kotlin and move them out of DescriptorDeserializer Include DescriptorDeserializer into context Use new context in injectors Drop Deserializers abstraction --- .../di/InjectorForJavaDescriptorResolver.java | 20 +- .../di/InjectorForLazyResolveWithJava.java | 20 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 20 +- .../AnnotationDescriptorDeserializer.java | 2 +- .../kotlin/BaseDescriptorDeserializer.java | 2 +- .../ConstantDescriptorDeserializer.java | 2 +- .../kotlin/DescriptorDeserializers.java | 52 ---- .../DeserializationGlobalContextForJava.kt | 36 +++ .../DeserializedDescriptorResolver.java | 65 +---- .../resolve/kotlin/JavaDescriptorFinder.kt | 41 +++ .../types/lang/BuiltinsPackageFragment.java | 17 +- .../AbstractDescriptorFinder.java | 25 +- .../serialization/DescriptorDeserializer.java | 250 ++++-------------- .../serialization/TypeDeserializer.java | 71 ++--- .../serialization/context/context.kt | 106 ++++++++ .../descriptors/AnnotatedCallableKind.java | 24 ++ .../descriptors/AnnotationDeserializer.java | 2 - .../descriptors/ConstantDeserializer.java | 2 - .../DeserializedClassDescriptor.java | 90 +++---- .../descriptors/DeserializedMemberScope.java | 51 ++-- .../DeserializedPackageMemberScope.java | 40 ++- .../DeserializedSimpleFunctionDescriptor.java | 13 +- .../descriptors/Deserializers.java | 48 ---- .../serialization/protoEnumMapping.kt | 68 +++++ .../caches/JetFromJavaDescriptorHelper.java | 2 +- .../libraries/DeserializerForDecompiler.kt | 21 +- 26 files changed, 498 insertions(+), 592 deletions(-) delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java create mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt create mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt create mode 100644 core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt create mode 100644 core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java delete mode 100644 core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java create mode 100644 core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt 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 c36c6e7a805..2798ec84d4f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -34,7 +34,8 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; @@ -63,7 +64,8 @@ public class InjectorForJavaDescriptorResolver { private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; - private final DescriptorDeserializers descriptorDeserializers; + private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; + private final JavaDescriptorFinder javaDescriptorFinder; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final DescriptorDeserializersStorage descriptorDeserializersStorage; private final ConstantDescriptorDeserializer constantDescriptorDeserializer; @@ -90,10 +92,11 @@ public class InjectorForJavaDescriptorResolver { this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule()); this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule()); this.memberFilter = org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter.ALWAYS_TRUE; - this.descriptorDeserializers = new DescriptorDeserializers(); + this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); - this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); + this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter); + this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); this.javaClassFinder.setProject(project); @@ -108,15 +111,8 @@ public class InjectorForJavaDescriptorResolver { psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver); psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - deserializedDescriptorResolver.setDeserializers(descriptorDeserializers); + deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); - deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver); - deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider); - deserializedDescriptorResolver.setMemberFilter(memberFilter); - deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager); - - descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); - descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); 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 fe64f388414..285f885e12d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -56,7 +56,8 @@ import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; @@ -107,7 +108,8 @@ public class InjectorForLazyResolveWithJava { private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; - private final DescriptorDeserializers descriptorDeserializers; + private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; + private final JavaDescriptorFinder javaDescriptorFinder; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final DescriptorDeserializersStorage descriptorDeserializersStorage; private final ConstantDescriptorDeserializer constantDescriptorDeserializer; @@ -158,10 +160,11 @@ public class InjectorForLazyResolveWithJava { this.jetImportsFactory = new JetImportsFactory(); this.scopeProvider = new ScopeProvider(getResolveSession()); this.scriptBodyResolver = new ScriptBodyResolver(); - this.descriptorDeserializers = new DescriptorDeserializers(); + this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); - this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); + this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(lockBasedStorageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter); + this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(lockBasedStorageManager); this.resolveSession.setAnnotationResolve(annotationResolver); this.resolveSession.setDescriptorResolver(descriptorResolver); @@ -238,15 +241,8 @@ public class InjectorForLazyResolveWithJava { scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); - deserializedDescriptorResolver.setDeserializers(descriptorDeserializers); + deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); - deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver); - deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider); - deserializedDescriptorResolver.setMemberFilter(memberFilter); - deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager); - - descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); - descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); 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 6f8294f7ef0..193881af9ef 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -66,7 +66,8 @@ import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; -import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializers; +import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava; +import org.jetbrains.jet.lang.resolve.kotlin.JavaDescriptorFinder; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage; import org.jetbrains.jet.lang.resolve.kotlin.ConstantDescriptorDeserializer; @@ -127,7 +128,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider; private final GlobalJavaResolverContext globalJavaResolverContext; private final DeserializedDescriptorResolver deserializedDescriptorResolver; - private final DescriptorDeserializers descriptorDeserializers; + private final DeserializationGlobalContextForJava deserializationGlobalContextForJava; + private final JavaDescriptorFinder javaDescriptorFinder; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final DescriptorDeserializersStorage descriptorDeserializersStorage; private final ConstantDescriptorDeserializer constantDescriptorDeserializer; @@ -189,10 +191,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.overloadResolver = new OverloadResolver(); this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); - this.descriptorDeserializers = new DescriptorDeserializers(); + this.javaDescriptorFinder = new JavaDescriptorFinder(getJavaDescriptorResolver(), lazyJavaPackageFragmentProvider); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); - this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager); this.constantDescriptorDeserializer = new ConstantDescriptorDeserializer(); + this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, javaDescriptorFinder, annotationDescriptorDeserializer, constantDescriptorDeserializer, lazyJavaPackageFragmentProvider, memberFilter); + this.descriptorDeserializersStorage = new DescriptorDeserializersStorage(storageManager); this.topDownAnalyzer.setBodyResolver(bodyResolver); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); @@ -320,15 +323,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); typeHierarchyResolver.setTrace(bindingTrace); - deserializedDescriptorResolver.setDeserializers(descriptorDeserializers); + deserializedDescriptorResolver.setContext(deserializationGlobalContextForJava); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); - deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver); - deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider); - deserializedDescriptorResolver.setMemberFilter(memberFilter); - deserializedDescriptorResolver.setStorageManager(storageManager); - - descriptorDeserializers.setAnnotationDescriptorDeserializer(annotationDescriptorDeserializer); - descriptorDeserializers.setConstantDescriptorDeserializer(constantDescriptorDeserializer); annotationDescriptorDeserializer.setClassResolver(javaDescriptorResolver); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); 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 d7d0c547e04..47d759d932d 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 @@ -46,7 +46,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; public class AnnotationDescriptorDeserializer extends BaseDescriptorDeserializer implements AnnotationDeserializer { diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java index 2bd12420109..6129daef6dd 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/BaseDescriptorDeserializer.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isTrait; import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; 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 index 0f240a14531..e1104fe2ee3 100644 --- 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 @@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; import javax.inject.Inject; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; import static org.jetbrains.jet.lang.resolve.kotlin.DescriptorDeserializersStorage.MemberSignature; public class ConstantDescriptorDeserializer extends BaseDescriptorDeserializer implements ConstantDeserializer { 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 deleted file mode 100644 index eec84302c3d..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DescriptorDeserializers.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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.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; - -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/DeserializationGlobalContextForJava.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt new file mode 100644 index 00000000000..7b5c5df582a --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializationGlobalContextForJava.kt @@ -0,0 +1,36 @@ +/* + * 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.jet.descriptors.serialization.context.DeserializationGlobalContext +import org.jetbrains.jet.storage.StorageManager +import org.jetbrains.jet.descriptors.serialization.DescriptorFinder +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer +import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider +import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider +import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter + +public class DeserializationGlobalContextForJava( + storageManager: StorageManager, + descriptorFinder: JavaDescriptorFinder, + annotationDeserializer: AnnotationDescriptorDeserializer, + constantDeserializer: ConstantDescriptorDeserializer, + packageFragmentProvider: LazyJavaPackageFragmentProvider, + memberFilter: MemberFilter +) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer, + constantDeserializer, packageFragmentProvider, memberFilter) \ No newline at end of file diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java index 22a47b0f70b..f35d0f30dcc 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java @@ -19,76 +19,28 @@ package org.jetbrains.jet.lang.resolve.kotlin; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.ClassData; -import org.jetbrains.jet.descriptors.serialization.ClassId; -import org.jetbrains.jet.descriptors.serialization.DescriptorFinder; import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; -import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.storage.StorageManager; import javax.inject.Inject; -import java.util.Collection; -import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName; import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.CLASS; import static org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader.Kind.PACKAGE_FACADE; public final class DeserializedDescriptorResolver { - private DescriptorDeserializers deserializers; - - private MemberFilter memberFilter; - - private StorageManager storageManager; - - private JavaPackageFragmentProvider javaPackageFragmentProvider; - - private JavaDescriptorResolver javaDescriptorResolver; + private DeserializationGlobalContextForJava context; private ErrorReporter errorReporter; - @NotNull - private final DescriptorFinder javaDescriptorFinder = new DescriptorFinder() { - @Nullable - @Override - public ClassDescriptor findClass(@NotNull ClassId classId) { - return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName())); - } - - @NotNull - @Override - public Collection getClassNames(@NotNull FqName packageName) { - return javaPackageFragmentProvider.getClassNamesInPackage(packageName); - } - }; - @Inject - public void setDeserializers(DescriptorDeserializers deserializers) { - this.deserializers = deserializers; - } - - @Inject - public void setMemberFilter(MemberFilter memberFilter) { - this.memberFilter = memberFilter; - } - - @Inject - public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) { - this.javaPackageFragmentProvider = javaPackageFragmentProvider; - } - - @Inject - public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) { - this.javaDescriptorResolver = javaDescriptorResolver; + public void setContext(DeserializationGlobalContextForJava context) { + this.context = context; } @Inject @@ -96,18 +48,12 @@ public final class DeserializedDescriptorResolver { this.errorReporter = errorReporter; } - @Inject - public void setStorageManager(StorageManager storageManager) { - this.storageManager = storageManager; - } - @Nullable public ClassDescriptor resolveClass(@NotNull KotlinJvmBinaryClass kotlinClass) { String[] data = readData(kotlinClass, CLASS); if (data != null) { ClassData classData = JavaProtoBufUtil.readClassDataFrom(data); - return new DeserializedClassDescriptor(storageManager, deserializers, javaDescriptorFinder, - javaPackageFragmentProvider, classData.getNameResolver(), classData.getClassProto()); + return new DeserializedClassDescriptor(context, classData); } return null; } @@ -116,8 +62,7 @@ public final class DeserializedDescriptorResolver { public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) { String[] data = readData(kotlinClass, PACKAGE_FACADE); if (data != null) { - return new DeserializedPackageMemberScope(storageManager, descriptor, deserializers, - memberFilter, javaDescriptorFinder, JavaProtoBufUtil.readPackageDataFrom(data)); + return new DeserializedPackageMemberScope(descriptor, JavaProtoBufUtil.readPackageDataFrom(data), context); } return null; } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt new file mode 100644 index 00000000000..43b79efcd45 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt @@ -0,0 +1,41 @@ +/* + * 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.Nullable +import org.jetbrains.jet.descriptors.serialization.ClassId +import org.jetbrains.jet.descriptors.serialization.DescriptorFinder +import org.jetbrains.jet.lang.descriptors.ClassDescriptor +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver +import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName + +public class JavaDescriptorFinder( + private val javaDescriptorResolver: DependencyClassByQualifiedNameResolver, + private val javaPackageFragmentProvider: JavaPackageFragmentProvider +) : DescriptorFinder { + + override fun findClass(classId: ClassId): ClassDescriptor? { + return javaDescriptorResolver.resolveClass(kotlinFqNameToJavaFqName(classId.asSingleFqName())) + } + + override fun getClassNames(packageName: FqName): Collection { + return javaPackageFragmentProvider.getClassNamesInPackage(packageName) + } +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java index 99851bd0752..365f1855773 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java @@ -20,9 +20,8 @@ import kotlin.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; -import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; -import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers; -import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; +import org.jetbrains.jet.descriptors.serialization.descriptors.*; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl; @@ -52,9 +51,13 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl { packageFragmentProvider = new BuiltinsPackageFragmentProvider(); - // TODO: support annotations - members = new DeserializedPackageMemberScope(storageManager, this, Deserializers.UNSUPPORTED, MemberFilter.ALWAYS_TRUE, - new BuiltInsDescriptorFinder(storageManager), loadPackage(), nameResolver); + DeserializationContext context = new DeserializationContext( + storageManager, new BuiltInsDescriptorFinder(storageManager), + // TODO: support annotations + AnnotationDeserializer.UNSUPPORTED, ConstantDeserializer.UNSUPPORTED, packageFragmentProvider, + MemberFilter.ALWAYS_TRUE, nameResolver + ); + members = new DeserializedPackageMemberScope(this, loadPackage(), context); } @NotNull @@ -119,7 +122,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl { public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) { // TODO: support annotations - super(storageManager, Deserializers.UNSUPPORTED, packageFragmentProvider); + super(storageManager, AnnotationDeserializer.UNSUPPORTED, ConstantDeserializer.UNSUPPORTED, packageFragmentProvider); classNames = storageManager.createLazyValue(new Function0>() { @Override diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java index 27a2eeb9123..4fb710a6010 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java @@ -19,8 +19,8 @@ package org.jetbrains.jet.descriptors.serialization; import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers; -import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext; +import org.jetbrains.jet.descriptors.serialization.descriptors.*; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; @@ -28,26 +28,21 @@ import org.jetbrains.jet.storage.StorageManager; public abstract class AbstractDescriptorFinder implements DescriptorFinder { private final MemoizedFunctionToNullable findClass; - private final Deserializers deserializers; public AbstractDescriptorFinder( - @NotNull final StorageManager storageManager, - @NotNull Deserializers deserializers, - @NotNull final PackageFragmentProvider packageFragmentProvider + @NotNull StorageManager storageManager, + @NotNull AnnotationDeserializer annotationDeserializer, + @NotNull ConstantDeserializer constantDeserializer, + @NotNull PackageFragmentProvider packageFragmentProvider ) { - this.deserializers = deserializers; - + final DeserializationGlobalContext deserializationGlobalContext = + new DeserializationGlobalContext(storageManager, this, annotationDeserializer, constantDeserializer, + packageFragmentProvider, MemberFilter.ALWAYS_TRUE); this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { @Override public ClassDescriptor invoke(ClassId classId) { ClassData classData = getClassData(classId); - if (classData == null) { - return null; - } - - AbstractDescriptorFinder _this = AbstractDescriptorFinder.this; - return new DeserializedClassDescriptor(storageManager, _this.deserializers, _this, packageFragmentProvider, - classData.getNameResolver(), classData.getClassProto()); + return classData == null ? null : new DeserializedClassDescriptor(deserializationGlobalContext, classData); } }); } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java index c31892c63c9..6ecf1af1356 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorDeserializer.java @@ -19,15 +19,20 @@ package org.jetbrains.jet.descriptors.serialization; import kotlin.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.descriptors.*; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes; +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; +import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPropertyDescriptor; +import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpleFunctionDescriptor; +import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import org.jetbrains.jet.lang.descriptors.impl.*; +import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.PropertyGetterDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.PropertySetterDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.DescriptorFactory; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.types.Variance; -import org.jetbrains.jet.storage.StorageManager; import java.util.ArrayList; import java.util.Collections; @@ -35,86 +40,16 @@ import java.util.List; import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable; import static org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter; -import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; +import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*; + +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotatedCallableKind; public class DescriptorDeserializer { - @NotNull - public static DescriptorDeserializer create( - @NotNull StorageManager storageManager, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NameResolver nameResolver, - @NotNull DescriptorFinder descriptorFinder, - @NotNull Deserializers deserializers - ) { - return new DescriptorDeserializer(storageManager, - new TypeDeserializer(storageManager, null, nameResolver, descriptorFinder, - "Deserializer for " + containingDeclaration.getName(), NONE), - containingDeclaration, nameResolver, deserializers); - } + private final DeserializationContextWithTypes context; - @NotNull - public static DescriptorDeserializer create( - @NotNull StorageManager storageManager, - @NotNull TypeDeserializer typeDeserializer, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NameResolver nameResolver, - @NotNull Deserializers deserializers - ) { - return new DescriptorDeserializer(storageManager, typeDeserializer, containingDeclaration, nameResolver, deserializers); - } - - private final DeclarationDescriptor containingDeclaration; - private final NameResolver nameResolver; - private final TypeDeserializer typeDeserializer; - private final Deserializers deserializers; - - private final StorageManager storageManager; - - private DescriptorDeserializer( - @NotNull StorageManager storageManager, - @NotNull TypeDeserializer typeDeserializer, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NameResolver nameResolver, - @NotNull Deserializers deserializers - ) { - this.storageManager = storageManager; - this.typeDeserializer = typeDeserializer; - this.containingDeclaration = containingDeclaration; - this.nameResolver = nameResolver; - this.deserializers = deserializers; - } - - @NotNull - public TypeDeserializer getTypeDeserializer() { - return typeDeserializer; - } - - @NotNull - public NameResolver getNameResolver() { - return nameResolver; - } - - @NotNull - public DescriptorDeserializer createChildDeserializer( - @NotNull DeclarationDescriptor descriptor, - @NotNull final List typeParameterProtos, - @NotNull final List typeParameters - ) { - TypeDeserializer childTypeDeserializer = new TypeDeserializer( - storageManager, - typeDeserializer, "Child deserializer for " + descriptor.getName(), - new TypeDeserializer.TypeParameterResolver() { - @NotNull - @Override - public List getTypeParameters(@NotNull TypeDeserializer typeDeserializer) { - List descriptors = typeParameters(typeParameterProtos, typeDeserializer); - typeParameters.addAll(descriptors); - return descriptors; - } - }); - return create(storageManager, childTypeDeserializer, descriptor, nameResolver, deserializers); + public DescriptorDeserializer(@NotNull DeserializationContextWithTypes context) { + this.context = context; } @NotNull @@ -137,25 +72,25 @@ public class DescriptorDeserializer { final int flags = proto.getFlags(); DeserializedPropertyDescriptor property = new DeserializedPropertyDescriptor( - containingDeclaration, + context.getContainingDeclaration(), null, getAnnotations(proto, flags, AnnotatedCallableKind.PROPERTY), modality(Flags.MODALITY.get(flags)), visibility(Flags.VISIBILITY.get(flags)), Flags.CALLABLE_KIND.get(flags) == Callable.CallableKind.VAR, - nameResolver.getName(proto.getName()), - memberKind(Flags.MEMBER_KIND.get(flags)), + context.getNameResolver().getName(proto.getName()), + SerializationPackage.memberKind(Flags.MEMBER_KIND.get(flags)), proto, - nameResolver + context.getNameResolver() ); List typeParameters = new ArrayList(proto.getTypeParameterCount()); - DescriptorDeserializer local = createChildDeserializer(property, proto.getTypeParameterList(), typeParameters); + DeserializationContextWithTypes local = context.childContext(property, proto.getTypeParameterList(), typeParameters); property.setType( - local.typeDeserializer.type(proto.getReturnType()), + local.getTypeDeserializer().type(proto.getReturnType()), typeParameters, getExpectedThisObject(), - local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null) + local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null) ); PropertyGetterDescriptorImpl getter = null; @@ -168,7 +103,8 @@ public class DescriptorDeserializer { getter = new PropertyGetterDescriptorImpl(property, getAnnotations(proto, getterFlags, AnnotatedCallableKind.PROPERTY_GETTER), modality(Flags.MODALITY.get(getterFlags)), - visibility(Flags.VISIBILITY.get(getterFlags)), isNotDefault, !isNotDefault, + visibility(Flags.VISIBILITY.get(getterFlags)), + isNotDefault, !isNotDefault, property.getKind(), null); } else { @@ -184,11 +120,13 @@ public class DescriptorDeserializer { setter = new PropertySetterDescriptorImpl(property, getAnnotations(proto, setterFlags, AnnotatedCallableKind.PROPERTY_SETTER), modality(Flags.MODALITY.get(setterFlags)), - visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, !isNotDefault, + visibility(Flags.VISIBILITY.get(setterFlags)), isNotDefault, + !isNotDefault, property.getKind(), null); - DescriptorDeserializer setterLocal = local.createChildDeserializer(setter, Collections.emptyList(), - Collections.emptyList()); - List valueParameters = setterLocal.valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER); + DeserializationContextWithTypes setterLocal = local.childContext(setter, Collections.emptyList(), + Collections.emptyList()); + List valueParameters + = setterLocal.getDeserializer().valueParameters(proto, AnnotatedCallableKind.PROPERTY_SETTER); assert valueParameters.size() == 1 : "Property setter should have a single value parameter: " + setter; setter.initialize(valueParameters.get(0)); } @@ -199,15 +137,16 @@ public class DescriptorDeserializer { if (Flags.HAS_CONSTANT.get(flags)) { property.setCompileTimeInitializer( - storageManager.createNullableLazyValue(new Function0>() { + context.getStorageManager().createNullableLazyValue(new Function0>() { @Nullable @Override public CompileTimeConstant invoke() { + DeclarationDescriptor containingDeclaration = context.getContainingDeclaration(); assert containingDeclaration instanceof ClassOrPackageFragmentDescriptor : "Only members in classes or package fragments should be serialized: " + containingDeclaration; - return deserializers.getConstantDeserializer().loadPropertyConstant( + return context.getConstantDeserializer().loadPropertyConstant( (ClassOrPackageFragmentDescriptor) containingDeclaration, - proto, nameResolver, + proto, context.getNameResolver(), AnnotatedCallableKind.PROPERTY); } }) @@ -223,18 +162,18 @@ public class DescriptorDeserializer { private CallableMemberDescriptor loadFunction(@NotNull Callable proto) { int flags = proto.getFlags(); DeserializedSimpleFunctionDescriptor function = DeserializedSimpleFunctionDescriptor.create( - containingDeclaration, proto, - deserializers, - nameResolver + context.getContainingDeclaration(), proto, + context.getAnnotationDeserializer(), + context.getNameResolver() ); List typeParameters = new ArrayList(proto.getTypeParameterCount()); - DescriptorDeserializer local = createChildDeserializer(function, proto.getTypeParameterList(), typeParameters); + DeserializationContextWithTypes local = context.childContext(function, proto.getTypeParameterList(), typeParameters); function.initialize( - local.typeDeserializer.typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null), + local.getTypeDeserializer().typeOrNull(proto.hasReceiverType() ? proto.getReceiverType() : null), getExpectedThisObject(), typeParameters, - local.valueParameters(proto, AnnotatedCallableKind.FUNCTION), - local.typeDeserializer.type(proto.getReturnType()), + local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION), + local.getTypeDeserializer().type(proto.getReturnType()), modality(Flags.MODALITY.get(flags)), visibility(Flags.VISIBILITY.get(flags)) ); @@ -243,33 +182,34 @@ public class DescriptorDeserializer { @Nullable private ReceiverParameterDescriptor getExpectedThisObject() { + DeclarationDescriptor containingDeclaration = context.getContainingDeclaration(); return containingDeclaration instanceof ClassDescriptor ? ((ClassDescriptor) containingDeclaration).getThisAsReceiverParameter() : null; } @NotNull private CallableMemberDescriptor loadConstructor(@NotNull Callable proto) { - ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; + ClassDescriptor classDescriptor = (ClassDescriptor) context.getContainingDeclaration(); ConstructorDescriptorImpl descriptor = ConstructorDescriptorImpl.create( classDescriptor, getAnnotations(proto, proto.getFlags(), AnnotatedCallableKind.FUNCTION), // TODO: primary true); List typeParameters = new ArrayList(proto.getTypeParameterCount()); - DescriptorDeserializer local = createChildDeserializer(descriptor, Collections.emptyList(), typeParameters); + DeserializationContextWithTypes local = context.childContext(descriptor, Collections.emptyList(), typeParameters); descriptor.initialize( classDescriptor.getTypeConstructor().getParameters(), - local.valueParameters(proto, AnnotatedCallableKind.FUNCTION), + local.getDeserializer().valueParameters(proto, AnnotatedCallableKind.FUNCTION), visibility(Flags.VISIBILITY.get(proto.getFlags())), DescriptorUtils.isConstructorOfStaticNestedClass(descriptor) ); - descriptor.setReturnType(local.typeDeserializer.type(proto.getReturnType())); + descriptor.setReturnType(local.getTypeDeserializer().type(proto.getReturnType())); return descriptor; } @NotNull private Annotations getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) { - return getAnnotations(containingDeclaration, proto, flags, kind, deserializers.getAnnotationDeserializer(), nameResolver); + return getAnnotations(context.getContainingDeclaration(), proto, flags, kind, context.getAnnotationDeserializer(), context.getNameResolver()); } public static Annotations getAnnotations( @@ -288,71 +228,6 @@ public class DescriptorDeserializer { : Annotations.EMPTY; } - public static CallableMemberDescriptor.Kind memberKind(Callable.MemberKind memberKind) { - switch (memberKind) { - case DECLARATION: - return CallableMemberDescriptor.Kind.DECLARATION; - case FAKE_OVERRIDE: - return CallableMemberDescriptor.Kind.FAKE_OVERRIDE; - case DELEGATION: - return CallableMemberDescriptor.Kind.DELEGATION; - case SYNTHESIZED: - return CallableMemberDescriptor.Kind.SYNTHESIZED; - } - throw new IllegalArgumentException("Unknown member kind: " + memberKind); - } - - @NotNull - public static Modality modality(@NotNull ProtoBuf.Modality modality) { - switch (modality) { - case FINAL: - return Modality.FINAL; - case OPEN: - return Modality.OPEN; - case ABSTRACT: - return Modality.ABSTRACT; - } - throw new IllegalArgumentException("Unknown modality: " + modality); - } - - @NotNull - public static Visibility visibility(@NotNull ProtoBuf.Visibility visibility) { - switch (visibility) { - case INTERNAL: - return Visibilities.INTERNAL; - case PRIVATE: - return Visibilities.PRIVATE; - case PROTECTED: - return Visibilities.PROTECTED; - case PUBLIC: - return Visibilities.PUBLIC; - case EXTRA: - throw new UnsupportedOperationException("Extra visibilities are not supported yet"); // TODO - } - throw new IllegalArgumentException("Unknown visibility: " + visibility); - } - - @NotNull - public static ClassKind classKind(@NotNull ProtoBuf.Class.Kind kind) { - switch (kind) { - case CLASS: - return ClassKind.CLASS; - case TRAIT: - return ClassKind.TRAIT; - case ENUM_CLASS: - return ClassKind.ENUM_CLASS; - case ENUM_ENTRY: - return ClassKind.ENUM_ENTRY; - case ANNOTATION_CLASS: - return ClassKind.ANNOTATION_CLASS; - case OBJECT: - return ClassKind.OBJECT; - case CLASS_OBJECT: - return ClassKind.CLASS_OBJECT; - } - throw new IllegalArgumentException("Unknown class kind: " + kind); - } - @NotNull public List typeParameters( @NotNull List protos, @@ -362,11 +237,11 @@ public class DescriptorDeserializer { for (int i = 0; i < protos.size(); i++) { TypeParameter proto = protos.get(i); DeserializedTypeParameterDescriptor descriptor = new DeserializedTypeParameterDescriptor( - storageManager, + context.getStorageManager(), typeDeserializer, proto, - containingDeclaration, - nameResolver.getName(proto.getName()), + context.getContainingDeclaration(), + context.getNameResolver().getName(proto.getName()), variance(proto.getVariance()), proto.getReified(), i @@ -376,21 +251,9 @@ public class DescriptorDeserializer { return result; } - private static Variance variance(TypeParameter.Variance proto) { - switch (proto) { - case IN: - return Variance.IN_VARIANCE; - case OUT: - return Variance.OUT_VARIANCE; - case INV: - return Variance.INVARIANT; - } - throw new IllegalStateException("Unknown projection: " + proto); - } - @NotNull private List valueParameters(@NotNull Callable callable, @NotNull AnnotatedCallableKind kind) { - DeclarationDescriptor containerOfCallable = containingDeclaration.getContainingDeclaration(); + DeclarationDescriptor containerOfCallable = context.getContainingDeclaration().getContainingDeclaration(); assert containerOfCallable instanceof ClassOrPackageFragmentDescriptor : "Only members in classes or package fragments should be serialized: " + containerOfCallable; ClassOrPackageFragmentDescriptor classOrPackage = (ClassOrPackageFragmentDescriptor) containerOfCallable; @@ -400,14 +263,14 @@ public class DescriptorDeserializer { for (int i = 0; i < protos.size(); i++) { Callable.ValueParameter proto = protos.get(i); result.add(new ValueParameterDescriptorImpl( - containingDeclaration, + context.getContainingDeclaration(), null, i, getAnnotations(classOrPackage, callable, kind, proto), - nameResolver.getName(proto.getName()), - typeDeserializer.type(proto.getType()), + context.getNameResolver().getName(proto.getName()), + context.getTypeDeserializer().type(proto.getType()), Flags.DECLARES_DEFAULT_VALUE.get(proto.getFlags()), - typeDeserializer.typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null)) + context.getTypeDeserializer().typeOrNull(proto.hasVarargElementType() ? proto.getVarargElementType() : null)) ); } return result; @@ -421,7 +284,8 @@ public class DescriptorDeserializer { @NotNull Callable.ValueParameter valueParameter ) { return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags()) - ? deserializers.getAnnotationDeserializer().loadValueParameterAnnotations(classOrPackage, callable, nameResolver, kind, valueParameter) + ? context.getAnnotationDeserializer() + .loadValueParameterAnnotations(classOrPackage, callable, context.getNameResolver(), kind, valueParameter) : Annotations.EMPTY; } } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java index 20dc60e8bd9..7fce8635c68 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java @@ -21,6 +21,8 @@ import kotlin.Function0; import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.ReadOnly; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; @@ -30,12 +32,13 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.storage.MemoizedFunctionToNullable; import org.jetbrains.jet.storage.NotNullLazyValue; -import org.jetbrains.jet.storage.StorageManager; import java.util.ArrayList; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.variance; + public class TypeDeserializer { public interface TypeParameterResolver { @@ -48,11 +51,10 @@ public class TypeDeserializer { }; @NotNull + @ReadOnly List getTypeParameters(@NotNull TypeDeserializer typeDeserializer); } - private final NameResolver nameResolver; - private final DescriptorFinder descriptorFinder; private final TypeDeserializer parent; // never written to after constructor returns @@ -62,45 +64,29 @@ public class TypeDeserializer { private final String debugName; - private final StorageManager storageManager; + private final DeserializationContext context; public TypeDeserializer( - @NotNull StorageManager storageManager, - @NotNull TypeDeserializer parent, - @NotNull String debugName, - @NotNull TypeParameterResolver typeParameterResolver - ) { - this(storageManager, parent, parent.nameResolver, parent.descriptorFinder, debugName, typeParameterResolver); - } - - public TypeDeserializer( - @NotNull StorageManager storageManager, + @NotNull DeserializationContext context, @Nullable TypeDeserializer parent, - @NotNull NameResolver nameResolver, - @NotNull DescriptorFinder descriptorFinder, @NotNull String debugName, @NotNull TypeParameterResolver typeParameterResolver ) { - this.storageManager = storageManager; this.parent = parent; - this.nameResolver = nameResolver; - this.descriptorFinder = descriptorFinder; this.debugName = debugName + (parent == null ? "" : ". Child of " + parent.debugName); + this.context = context; for (DeserializedTypeParameterDescriptor typeParameterDescriptor : typeParameterResolver.getTypeParameters(this)) { typeParameterDescriptors.put(typeParameterDescriptor.getProtoId(), typeParameterDescriptor); } - this.classDescriptors = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { - @Override - public ClassDescriptor invoke(Integer fqNameIndex) { - return computeClassDescriptor(fqNameIndex); - } - }); - } - - /* package */ DescriptorFinder getDescriptorFinder() { - return descriptorFinder; + this.classDescriptors = context.getStorageManager().createMemoizedFunctionWithNullableValues( + new Function1() { + @Override + public ClassDescriptor invoke(Integer fqNameIndex) { + return computeClassDescriptor(fqNameIndex); + } + }); } @Nullable @@ -122,7 +108,7 @@ public class TypeDeserializer { TypeConstructor typeConstructor = typeConstructor(constructorProto); if (typeConstructor == null) { String message = constructorProto.getKind() == ProtoBuf.Type.Constructor.Kind.CLASS - ? nameResolver.getClassId(id).asSingleFqName().asString() + ? context.getNameResolver().getClassId(id).asSingleFqName().asString() : "Unknown type parameter " + id; typeConstructor = ErrorUtils.createErrorType(message).getConstructor(); } @@ -159,8 +145,8 @@ public class TypeDeserializer { @Nullable private ClassDescriptor computeClassDescriptor(int fqNameIndex) { - ClassId classId = nameResolver.getClassId(fqNameIndex); - return descriptorFinder.findClass(classId); + ClassId classId = context.getNameResolver().getClassId(fqNameIndex); + return context.getDescriptorFinder().findClass(classId); } private List typeArguments(List protos) { @@ -172,22 +158,7 @@ public class TypeDeserializer { } private TypeProjection typeProjection(ProtoBuf.Type.Argument proto) { - return new TypeProjectionImpl( - variance(proto.getProjection()), - type(proto.getType()) - ); - } - - private static Variance variance(ProtoBuf.Type.Argument.Projection proto) { - switch (proto) { - case IN: - return Variance.IN_VARIANCE; - case OUT: - return Variance.OUT_VARIANCE; - case INV: - return Variance.INVARIANT; - } - throw new IllegalStateException("Unknown projection: " + proto); + return new TypeProjectionImpl(variance(proto.getProjection()), type(proto.getType())); } @NotNull @@ -215,13 +186,13 @@ public class TypeDeserializer { this.typeProto = proto; this.arguments = typeArguments(proto.getArgumentList()); - this.constructor = storageManager.createLazyValue(new Function0() { + this.constructor = context.getStorageManager().createLazyValue(new Function0() { @Override public TypeConstructor invoke() { return typeConstructor(typeProto); } }); - this.memberScope = storageManager.createLazyValue(new Function0() { + this.memberScope = context.getStorageManager().createLazyValue(new Function0() { @Override public JetScope invoke() { return computeMemberScope(); diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt new file mode 100644 index 00000000000..d84103a5a8d --- /dev/null +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt @@ -0,0 +1,106 @@ +/* + * 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.context + +import org.jetbrains.jet.storage.StorageManager +import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider +import org.jetbrains.jet.descriptors.serialization.DescriptorFinder +import org.jetbrains.jet.descriptors.serialization.NameResolver +import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantDeserializer +import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor +import org.jetbrains.jet.descriptors.serialization.TypeDeserializer +import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer +import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter +import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor +import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor +import org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver + +public open class DeserializationGlobalContext( + public val storageManager: StorageManager, + public val descriptorFinder: DescriptorFinder, + public val annotationDeserializer: AnnotationDeserializer, + public val constantDeserializer: ConstantDeserializer, + public val packageFragmentProvider: PackageFragmentProvider, + public val memberFilter: MemberFilter +) { + public fun withNameResolver(nameResolver: NameResolver): DeserializationContext { + return DeserializationContext(storageManager, descriptorFinder, annotationDeserializer, + constantDeserializer, packageFragmentProvider, memberFilter, nameResolver) + } +} + + +public open class DeserializationContext( + storageManager: StorageManager, + descriptorFinder: DescriptorFinder, + annotationDeserializer: AnnotationDeserializer, + constantDeserializer: ConstantDeserializer, + packageFragmentProvider: PackageFragmentProvider, + memberFilter: MemberFilter, + public val nameResolver: NameResolver +) : DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer, + constantDeserializer, packageFragmentProvider, memberFilter) { + fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes { + val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}", + TypeDeserializer.TypeParameterResolver.NONE) + return withTypes(containingDeclaration, typeDeserializer) + } + + fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes { + return DeserializationContextWithTypes(storageManager, descriptorFinder, annotationDeserializer, + constantDeserializer, packageFragmentProvider, memberFilter, + nameResolver, containingDeclaration, + typeDeserializer) + } + +} + + +class DeserializationContextWithTypes( + storageManager: StorageManager, + descriptorFinder: DescriptorFinder, + annotationDeserializer: AnnotationDeserializer, + constantDeserializer: ConstantDeserializer, + packageFragmentProvider: PackageFragmentProvider, + memberFilter: MemberFilter, + nameResolver: NameResolver, + val containingDeclaration: DeclarationDescriptor, + val typeDeserializer: TypeDeserializer +) : DeserializationContext(storageManager, descriptorFinder, annotationDeserializer, + constantDeserializer, packageFragmentProvider, memberFilter, nameResolver) { + val deserializer: DescriptorDeserializer = DescriptorDeserializer(this) + + public fun childContext( + descriptor: DeclarationDescriptor, + typeParameterProtos: List, + typeParameters: MutableList + ): DeserializationContextWithTypes { + val childTypeParameterResolver = object : TypeDeserializer.TypeParameterResolver { + override fun getTypeParameters(typeDeserializer: TypeDeserializer): List { + val descriptors = deserializer.typeParameters(typeParameterProtos, typeDeserializer) + typeParameters.addAll(descriptors) + return descriptors + } + } + val childTypeDeserializer = TypeDeserializer(this, typeDeserializer, "Child deserializer for " + descriptor.getName(), + childTypeParameterResolver) + return withTypes(descriptor, childTypeDeserializer) + } + +} diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java new file mode 100644 index 00000000000..87858ff474a --- /dev/null +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotatedCallableKind.java @@ -0,0 +1,24 @@ +/* + * 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; + +public enum AnnotatedCallableKind { + FUNCTION, + PROPERTY, + PROPERTY_GETTER, + PROPERTY_SETTER +} diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java index 0186a81646e..2f43230dc22 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/AnnotationDeserializer.java @@ -23,8 +23,6 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; -import static org.jetbrains.jet.descriptors.serialization.descriptors.Deserializers.AnnotatedCallableKind; - public interface AnnotationDeserializer { AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() { @NotNull diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java index 96b3c8b668c..a6329b1d858 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/ConstantDeserializer.java @@ -23,8 +23,6 @@ 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 diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java index cf3eeb56ccb..bc8eaf79b56 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java @@ -22,6 +22,9 @@ import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotations; import org.jetbrains.jet.lang.descriptors.impl.AbstractClassDescriptor; @@ -45,21 +48,17 @@ import org.jetbrains.jet.storage.StorageManager; import java.util.*; -import static org.jetbrains.jet.descriptors.serialization.TypeDeserializer.TypeParameterResolver.NONE; +import static org.jetbrains.jet.descriptors.serialization.SerializationPackage.*; import static org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName; public class DeserializedClassDescriptor extends AbstractClassDescriptor implements ClassDescriptor { private final ClassId classId; private final ProtoBuf.Class classProto; - private final StorageManager storageManager; - private final TypeDeserializer typeDeserializer; - private final DescriptorDeserializer deserializer; private final DeserializedMemberScope memberScope; private final NullableLazyValue primaryConstructor; - private final Deserializers deserializers; private final NotNullLazyValue annotations; private final NullableLazyValue classObjectDescriptor; @@ -72,33 +71,22 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme private final Visibility visibility; private final ClassKind kind; private final boolean isInner; - private final DescriptorFinder descriptorFinder; - private final PackageFragmentProvider packageFragmentProvider; + private final DeserializationContextWithTypes context; - public DeserializedClassDescriptor( - @NotNull StorageManager storageManager, - @NotNull Deserializers deserializers, - @NotNull DescriptorFinder descriptorFinder, - @NotNull PackageFragmentProvider packageFragmentProvider, - @NotNull NameResolver nameResolver, - @NotNull ProtoBuf.Class classProto - ) { - super(storageManager, nameResolver.getClassId(classProto.getFqName()).getRelativeClassName().shortName()); + public DeserializedClassDescriptor(@NotNull DeserializationGlobalContext globalContext, @NotNull ClassData classData) { + this(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto()); + } + + public DeserializedClassDescriptor(@NotNull DeserializationContext outerContext, @NotNull ProtoBuf.Class classProto) { + super(outerContext.getStorageManager(), + outerContext.getNameResolver().getClassId(classProto.getFqName()).getRelativeClassName().shortName()); this.classProto = classProto; - this.classId = nameResolver.getClassId(classProto.getFqName()); - this.storageManager = storageManager; - this.packageFragmentProvider = packageFragmentProvider; - this.descriptorFinder = descriptorFinder; + this.classId = outerContext.getNameResolver().getClassId(classProto.getFqName()); - TypeDeserializer notNullTypeDeserializer = new TypeDeserializer(storageManager, null, nameResolver, - descriptorFinder, "Deserializer for class " + getName(), NONE); - DescriptorDeserializer outerDeserializer = DescriptorDeserializer.create(storageManager, notNullTypeDeserializer, - this, nameResolver, deserializers); List typeParameters = new ArrayList(classProto.getTypeParameterCount()); - this.deserializer = outerDeserializer.createChildDeserializer(this, classProto.getTypeParameterList(), typeParameters); - this.typeDeserializer = deserializer.getTypeDeserializer(); + this.context = outerContext.withTypes(this).childContext(this, classProto.getTypeParameterList(), typeParameters); - this.containingDeclaration = storageManager.createLazyValue(new Function0() { + this.containingDeclaration = outerContext.getStorageManager().createLazyValue(new Function0() { @Override public DeclarationDescriptor invoke() { return computeContainingDeclaration(); @@ -106,30 +94,29 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme }); this.typeConstructor = new DeserializedClassTypeConstructor(typeParameters); - this.memberScope = new DeserializedClassMemberScope(storageManager, this); + this.memberScope = new DeserializedClassMemberScope(); int flags = classProto.getFlags(); - this.modality = DescriptorDeserializer.modality(Flags.MODALITY.get(flags)); - this.visibility = DescriptorDeserializer.visibility(Flags.VISIBILITY.get(flags)); - this.kind = DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(flags)); + this.modality = modality(Flags.MODALITY.get(flags)); + this.visibility = visibility(Flags.VISIBILITY.get(flags)); + this.kind = classKind(Flags.CLASS_KIND.get(flags)); this.isInner = Flags.INNER.get(flags); - this.deserializers = deserializers; - this.annotations = storageManager.createLazyValue(new Function0() { + this.annotations = context.getStorageManager().createLazyValue(new Function0() { @Override public Annotations invoke() { return computeAnnotations(); } }); - this.primaryConstructor = storageManager.createNullableLazyValue(new Function0() { + this.primaryConstructor = context.getStorageManager().createNullableLazyValue(new Function0() { @Override public ConstructorDescriptor invoke() { return computePrimaryConstructor(); } }); - this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0() { + this.classObjectDescriptor = context.getStorageManager().createNullableLazyValue(new Function0() { @Override public ClassDescriptor invoke() { return computeClassObjectDescriptor(); @@ -148,12 +135,13 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme @NotNull private DeclarationDescriptor computeContainingDeclaration() { if (classId.isTopLevelClass()) { - List fragments = packageFragmentProvider.getPackageFragments(classId.getPackageFqName()); + List fragments = + context.getPackageFragmentProvider().getPackageFragments(classId.getPackageFqName()); assert fragments.size() == 1 : "there should be exactly one package: " + fragments; return fragments.iterator().next(); } else { - ClassOrPackageFragmentDescriptor result = descriptorFinder.findClass(classId.getOuterClassId()); + ClassDescriptor result = context.getDescriptorFinder().findClass(classId.getOuterClassId()); return result != null ? result : ErrorUtils.getErrorModule(); } } @@ -192,7 +180,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) { return Annotations.EMPTY; } - return deserializers.getAnnotationDeserializer().loadClassAnnotations(this, classProto); + return context.getAnnotationDeserializer().loadClassAnnotations(this, classProto); } @NotNull @@ -218,7 +206,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme return descriptor; } - return (ConstructorDescriptor) deserializer.loadCallable(constructorProto.getData()); + return (ConstructorDescriptor) context.getDeserializer().loadCallable(constructorProto.getData()); } @Nullable @@ -254,11 +242,10 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme throw new IllegalStateException("Object should have a serialized class object: " + classId); } - return new DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider, - deserializer.getNameResolver(), classObjectProto.getData()); + return new DeserializedClassDescriptor(context, classObjectProto.getData()); } - return descriptorFinder.findClass(classId.createNestedClassId(getClassObjectName(getName()))); + return context.getDescriptorFinder().findClass(classId.createNestedClassId(getClassObjectName(getName()))); } @NotNull @@ -313,7 +300,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme private Collection computeSuperTypes() { List supertypes = new ArrayList(classProto.getSupertypeCount()); for (ProtoBuf.Type supertype : classProto.getSupertypeList()) { - supertypes.add(typeDeserializer.type(supertype)); + supertypes.add(context.getTypeDeserializer().type(supertype)); } return supertypes; } @@ -384,12 +371,12 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme } } - private static class DeserializedClassMemberScope extends DeserializedMemberScope { + private class DeserializedClassMemberScope extends DeserializedMemberScope { private final DeserializedClassDescriptor classDescriptor; - public DeserializedClassMemberScope(@NotNull StorageManager storageManager, @NotNull DeserializedClassDescriptor classDescriptor) { - super(storageManager, classDescriptor, classDescriptor.deserializer, classDescriptor.classProto.getMemberList()); - this.classDescriptor = classDescriptor; + public DeserializedClassMemberScope() { + super(context, DeserializedClassDescriptor.this.classProto.getMemberList()); + this.classDescriptor = DeserializedClassDescriptor.this; } @Override @@ -485,6 +472,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme this.nestedClassNames = nestedClassNames(); this.enumEntryNames = enumEntryNames(); + final StorageManager storageManager = context.getStorageManager(); final NotNullLazyValue> enumMemberNames = storageManager.createLazyValue(new Function0>() { @Override public Collection invoke() { @@ -500,7 +488,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme .create(storageManager, DeserializedClassDescriptor.this, name, enumMemberNames); } if (nestedClassNames.contains(name)) { - return descriptorFinder.findClass(classId.createNestedClassId(name)); + return context.getDescriptorFinder().findClass(classId.createNestedClassId(name)); } return null; } @@ -510,7 +498,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme @NotNull private Set nestedClassNames() { Set result = new HashSet(); - NameResolver nameResolver = deserializer.getNameResolver(); + NameResolver nameResolver = context.getNameResolver(); for (Integer index : classProto.getNestedClassNameList()) { result.add(nameResolver.getName(index)); } @@ -524,7 +512,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme } Set result = new HashSet(); - NameResolver nameResolver = deserializer.getNameResolver(); + NameResolver nameResolver = context.getNameResolver(); for (Integer index : classProto.getEnumEntryList()) { result.add(nameResolver.getName(index)); } @@ -543,7 +531,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme } } - final NameResolver nameResolver = deserializer.getNameResolver(); + final NameResolver nameResolver = context.getNameResolver(); return KotlinPackage.mapTo(classProto.getMemberList(), result, new Function1() { @Override public Name invoke(@NotNull ProtoBuf.Callable callable) { diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java index 1ed6a5f62d8..78ae9a64387 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java @@ -20,9 +20,9 @@ import kotlin.Function0; import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer; import org.jetbrains.jet.descriptors.serialization.Flags; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContextWithTypes; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -49,51 +49,50 @@ public abstract class DeserializedMemberScope implements JetScope { } }; - private final DeclarationDescriptor containingDeclaration; - private final DescriptorDeserializer deserializer; - // Never modified after creation private final Map> membersProtos; private final MemoizedFunctionToNotNull> functions; private final MemoizedFunctionToNotNull> properties; private final NotNullLazyValue> allDescriptors; + private final DeserializationContextWithTypes context; protected DeserializedMemberScope( - @NotNull StorageManager storageManager, - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull DescriptorDeserializer deserializer, + @NotNull DeserializationContextWithTypes context, @NotNull Collection membersList ) { - this.containingDeclaration = containingDeclaration; - this.deserializer = deserializer; - + this.context = context; this.membersProtos = groupByName(membersList); + StorageManager storageManager = context.getStorageManager(); this.functions = storageManager.createMemoizedFunction(new Function1>() { @Override public Collection invoke(Name name) { return computeFunctions(name); } }); - this.properties = storageManager.createMemoizedFunction(new Function1>() { - @Override - public Collection invoke(Name name) { - return computeProperties(name); - } - }); - this.allDescriptors = storageManager.createLazyValue(new Function0>() { - @Override - public Collection invoke() { - return computeAllDescriptors(); - } - }); + this.properties = storageManager.createMemoizedFunction( + new Function1>() { + @Override + public Collection invoke(Name name) { + return computeProperties(name); + } + } + ); + this.allDescriptors = storageManager.createLazyValue( + new Function0>() { + @Override + public Collection invoke() { + return computeAllDescriptors(); + } + } + ); } @NotNull private Map> groupByName(@NotNull Collection membersList) { Map> map = new HashMap>(); for (ProtoBuf.Callable memberProto : membersList) { - Name name = deserializer.getNameResolver().getName(memberProto.getName()); + Name name = context.getNameResolver().getName(memberProto.getName()); List protos = map.get(name); if (protos == null) { protos = new ArrayList(1); @@ -113,7 +112,7 @@ public abstract class DeserializedMemberScope implements JetScope { for (ProtoBuf.Callable memberProto : memberProtos) { if (callableKind.accept(Flags.CALLABLE_KIND.get(memberProto.getFlags()))) { //noinspection unchecked - descriptors.add((D) deserializer.loadCallable(memberProto)); + descriptors.add((D) context.getDeserializer().loadCallable(memberProto)); } } } @@ -179,7 +178,7 @@ public abstract class DeserializedMemberScope implements JetScope { @NotNull @Override public DeclarationDescriptor getContainingDeclaration() { - return containingDeclaration; + return context.getContainingDeclaration(); } @NotNull @@ -239,7 +238,7 @@ public abstract class DeserializedMemberScope implements JetScope { p.println(getClass().getSimpleName(), " {"); p.pushIndent(); - p.println("containingDeclaration = " + containingDeclaration); + p.println("containingDeclaration = " + getContainingDeclaration()); p.popIndent(); p.println("}"); diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java index c6644f16294..da28de91fe8 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java @@ -18,7 +18,11 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.*; +import org.jetbrains.jet.descriptors.serialization.ClassId; +import org.jetbrains.jet.descriptors.serialization.PackageData; +import org.jetbrains.jet.descriptors.serialization.ProtoBuf; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationContext; +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; @@ -26,54 +30,43 @@ import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.storage.StorageManager; import java.util.ArrayList; import java.util.Collection; import java.util.List; public class DeserializedPackageMemberScope extends DeserializedMemberScope { - private final DescriptorFinder descriptorFinder; private final FqName packageFqName; + private final DeserializationContext context; public DeserializedPackageMemberScope( - @NotNull StorageManager storageManager, @NotNull PackageFragmentDescriptor packageDescriptor, - @NotNull Deserializers deserializers, - @NotNull MemberFilter memberFilter, - @NotNull DescriptorFinder descriptorFinder, @NotNull ProtoBuf.Package proto, - @NotNull NameResolver nameResolver + @NotNull DeserializationContext context ) { - super(storageManager, packageDescriptor, - DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, deserializers), - getFilteredMembers(packageDescriptor, proto, memberFilter, nameResolver)); - this.descriptorFinder = descriptorFinder; + super(context.withTypes(packageDescriptor), getFilteredMembers(packageDescriptor, proto, context)); + this.context = context; this.packageFqName = packageDescriptor.getFqName(); } public DeserializedPackageMemberScope( - @NotNull StorageManager storageManager, @NotNull PackageFragmentDescriptor packageDescriptor, - @NotNull Deserializers deserializers, - @NotNull MemberFilter memberFilter, - @NotNull DescriptorFinder descriptorFinder, - @NotNull PackageData packageData + @NotNull PackageData packageData, + @NotNull DeserializationGlobalContext context ) { - this(storageManager, packageDescriptor, deserializers, memberFilter, descriptorFinder, packageData.getPackageProto(), - packageData.getNameResolver()); + this(packageDescriptor, packageData.getPackageProto(), context.withNameResolver(packageData.getNameResolver())); } @Nullable @Override protected ClassDescriptor getClassDescriptor(@NotNull Name name) { - return descriptorFinder.findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name))); + return context.getDescriptorFinder().findClass(new ClassId(packageFqName, FqNameUnsafe.topLevel(name))); } @Override protected void addAllClassDescriptors(@NotNull Collection result) { - for (Name className : descriptorFinder.getClassNames(packageFqName)) { + for (Name className : context.getDescriptorFinder().getClassNames(packageFqName)) { ClassDescriptor classDescriptor = getClassDescriptor(className); if (classDescriptor != null) { @@ -97,12 +90,11 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope { private static Collection getFilteredMembers( @NotNull PackageFragmentDescriptor packageDescriptor, @NotNull ProtoBuf.Package packageProto, - @NotNull MemberFilter memberFilter, - @NotNull NameResolver nameResolver + @NotNull DeserializationContext context ) { List result = new ArrayList(); for (ProtoBuf.Callable member : packageProto.getMemberList()) { - if (memberFilter.acceptPackagePartClass(packageDescriptor, member, nameResolver)) { + if (context.getMemberFilter().acceptPackagePartClass(packageDescriptor, member, context.getNameResolver())) { result.add(member); } } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java index 28722f0acf3..3cd4cb240d3 100644 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedSimpleFunctionDescriptor.java @@ -18,10 +18,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.descriptors.serialization.DescriptorDeserializer; -import org.jetbrains.jet.descriptors.serialization.Flags; -import org.jetbrains.jet.descriptors.serialization.NameResolver; -import org.jetbrains.jet.descriptors.serialization.ProtoBuf; +import org.jetbrains.jet.descriptors.serialization.*; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; @@ -87,19 +84,19 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript public static DeserializedSimpleFunctionDescriptor create( @NotNull DeclarationDescriptor containingDeclaration, @NotNull ProtoBuf.Callable proto, - @NotNull Deserializers deserializers, + @NotNull AnnotationDeserializer annotationDeserializer, @NotNull NameResolver nameResolver ) { Annotations annotations = DescriptorDeserializer.getAnnotations(containingDeclaration, proto, proto.getFlags(), - Deserializers.AnnotatedCallableKind.FUNCTION, - deserializers.getAnnotationDeserializer(), + AnnotatedCallableKind.FUNCTION, + annotationDeserializer, nameResolver); return new DeserializedSimpleFunctionDescriptor( containingDeclaration, null, annotations, nameResolver.getName(proto.getName()), - DescriptorDeserializer.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())), + SerializationPackage.memberKind(Flags.MEMBER_KIND.get(proto.getFlags())), proto, nameResolver); } diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java deleted file mode 100644 index 7e3b534cc62..00000000000 --- a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/Deserializers.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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; - -public interface Deserializers { - Deserializers UNSUPPORTED = new Deserializers() { - @NotNull - @Override - public AnnotationDeserializer getAnnotationDeserializer() { - return AnnotationDeserializer.UNSUPPORTED; - } - - @NotNull - @Override - public ConstantDeserializer getConstantDeserializer() { - return ConstantDeserializer.UNSUPPORTED; - } - }; - - @NotNull - AnnotationDeserializer getAnnotationDeserializer(); - - @NotNull - ConstantDeserializer getConstantDeserializer(); - - enum AnnotatedCallableKind { - FUNCTION, - PROPERTY, - PROPERTY_GETTER, - PROPERTY_SETTER - } -} diff --git a/core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt new file mode 100644 index 00000000000..8be65a79087 --- /dev/null +++ b/core/serialization/src/org/jetbrains/jet/descriptors/serialization/protoEnumMapping.kt @@ -0,0 +1,68 @@ +/* + * 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 + +import org.jetbrains.jet.descriptors.serialization.ProtoBuf.Callable +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor +import org.jetbrains.jet.lang.descriptors.Modality +import org.jetbrains.jet.lang.descriptors.Visibilities +import org.jetbrains.jet.lang.descriptors.ClassKind +import org.jetbrains.jet.descriptors.serialization.ProtoBuf.TypeParameter +import org.jetbrains.jet.lang.types.Variance + +fun memberKind(memberKind: Callable.MemberKind) = when (memberKind) { + ProtoBuf.Callable.MemberKind.DECLARATION -> CallableMemberDescriptor.Kind.DECLARATION + ProtoBuf.Callable.MemberKind.FAKE_OVERRIDE -> CallableMemberDescriptor.Kind.FAKE_OVERRIDE + ProtoBuf.Callable.MemberKind.DELEGATION -> CallableMemberDescriptor.Kind.DELEGATION + ProtoBuf.Callable.MemberKind.SYNTHESIZED -> CallableMemberDescriptor.Kind.SYNTHESIZED +} + +fun modality(modality: ProtoBuf.Modality) = when (modality) { + ProtoBuf.Modality.FINAL -> Modality.FINAL + ProtoBuf.Modality.OPEN -> Modality.OPEN + ProtoBuf.Modality.ABSTRACT -> Modality.ABSTRACT +} + +fun visibility(visibility: ProtoBuf.Visibility) = when (visibility) { + ProtoBuf.Visibility.INTERNAL -> Visibilities.INTERNAL + ProtoBuf.Visibility.PRIVATE -> Visibilities.PRIVATE + ProtoBuf.Visibility.PROTECTED -> Visibilities.PROTECTED + ProtoBuf.Visibility.PUBLIC -> Visibilities.PUBLIC + ProtoBuf.Visibility.EXTRA -> throw UnsupportedOperationException("Extra visibilities are not supported yet") +} + +public fun classKind(kind: ProtoBuf.Class.Kind): ClassKind = when (kind) { + ProtoBuf.Class.Kind.CLASS -> ClassKind.CLASS + ProtoBuf.Class.Kind.TRAIT -> ClassKind.TRAIT + ProtoBuf.Class.Kind.ENUM_CLASS -> ClassKind.ENUM_CLASS + ProtoBuf.Class.Kind.ENUM_ENTRY -> ClassKind.ENUM_ENTRY + ProtoBuf.Class.Kind.ANNOTATION_CLASS -> ClassKind.ANNOTATION_CLASS + ProtoBuf.Class.Kind.OBJECT -> ClassKind.OBJECT + ProtoBuf.Class.Kind.CLASS_OBJECT -> ClassKind.CLASS_OBJECT +} + +fun variance(variance: TypeParameter.Variance) = when (variance) { + ProtoBuf.TypeParameter.Variance.IN -> Variance.IN_VARIANCE + ProtoBuf.TypeParameter.Variance.OUT -> Variance.OUT_VARIANCE + ProtoBuf.TypeParameter.Variance.INV -> Variance.INVARIANT +} + +fun variance(variance: ProtoBuf.Type.Argument.Projection) = when (variance) { + ProtoBuf.Type.Argument.Projection.IN -> Variance.IN_VARIANCE + ProtoBuf.Type.Argument.Projection.OUT -> Variance.OUT_VARIANCE + ProtoBuf.Type.Argument.Projection.INV -> Variance.INVARIANT +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java b/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java index d23d4a2a49f..849003409bd 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java @@ -90,7 +90,7 @@ public class JetFromJavaDescriptorHelper { public static ClassKind getCompiledClassKind(@NotNull PsiClass psiClass) { ClassData classData = getClassData(psiClass); if (classData == null) return null; - return DescriptorDeserializer.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags())); + return SerializationPackage.classKind(Flags.CLASS_KIND.get(classData.getClassProto().getFlags())); } diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt index 0e728a5217b..c62292c0bc7 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt @@ -40,11 +40,11 @@ import org.jetbrains.jet.lang.resolve.java.PackageClassUtils import com.intellij.openapi.diagnostic.Logger 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 import org.jetbrains.jet.descriptors.serialization.descriptors.MemberFilter import org.jetbrains.jet.lang.resolve.java.structure.JavaClass +import org.jetbrains.jet.descriptors.serialization.context.DeserializationGlobalContext public fun DeserializerForDecompiler(classFile: VirtualFile): DeserializerForDecompiler { val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(classFile) @@ -68,12 +68,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di return Collections.emptyList() } val membersScope = DeserializedPackageMemberScope( - storageManager, createDummyPackageFragment(packageFqName), - deserializers, - MemberFilter.ALWAYS_TRUE, - descriptorFinder, - JavaProtoBufUtil.readPackageDataFrom(annotationData) + JavaProtoBufUtil.readPackageDataFrom(annotationData), + deserializationContext ) return membersScope.getAllDescriptors() } @@ -132,12 +129,6 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di constantDeserializer.setStorage(deserializerStorage) } - private val deserializers = DescriptorDeserializers(); - { - deserializers.setAnnotationDescriptorDeserializer(annotationDeserializer) - deserializers.setConstantDescriptorDeserializer(constantDeserializer) - } - private val descriptorFinder = object : DescriptorFinder { override fun findClass(classId: ClassId): ClassDescriptor? { return classes(classId) @@ -158,6 +149,9 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di } } + val deserializationContext = DeserializationGlobalContext(storageManager, descriptorFinder, annotationDeserializer, + constantDeserializer, packageFragmentProvider, MemberFilter.ALWAYS_TRUE) + private fun createDummyPackageFragment(fqName: FqName): MutablePackageFragmentDescriptor { return MutablePackageFragmentDescriptor(ErrorUtils.getErrorModule(), fqName) } @@ -184,8 +178,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di LOG.error("Annotation data missing for ${kotlinClass.getClassName()}") } val classData = JavaProtoBufUtil.readClassDataFrom(data!!) - return DeserializedClassDescriptor(storageManager, deserializers, descriptorFinder, packageFragmentProvider, - classData.getNameResolver(), classData.getClassProto()) + return DeserializedClassDescriptor(deserializationContext, classData) } // we need a "magic" way to obtain ClassId from FqName