Move caching of deserialized classes to new component ClassDeserializer

Drop AbstractDescriptorFinder

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt

@@ -98,9 +98,7 @@ public class LazyJavaPackageFragmentProvider(
 
     override fun getSubPackagesOf(fqName: FqName) = getPackageFragment(fqName)?.getMemberScope()?.getSubPackages().orEmpty()
 
-    internal val resolveKotlinBinaryClass = c.storageManager.createMemoizedFunctionWithNullableValues {
+    fun resolveKotlinBinaryClass(kotlinClass: KotlinJvmBinaryClass) = c.deserializedDescriptorResolver.resolveClassCached(kotlinClass)
-        (kotlinClass: KotlinJvmBinaryClass) -> c.deserializedDescriptorResolver.resolveClass(kotlinClass)
-    }
 
     fun getClass(javaClass: JavaClass): ClassDescriptor? = c.javaClassResolver.resolveClass(javaClass)
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java

@@ -19,7 +19,9 @@ 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.JavaProtoBufUtil;
+import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -57,6 +59,17 @@ public final class DeserializedDescriptorResolver {
         }
         return null;
     }
+    @Nullable
+    public ClassDescriptor resolveClassCached(@NotNull KotlinJvmBinaryClass kotlinClass) {
+        String[] data = readData(kotlinClass, CLASS);
+        if (data != null) {
+            ClassData classData = JavaProtoBufUtil.readClassDataFrom(data);
+            NameResolver nameResolver = classData.getNameResolver();
+            ClassId classId = nameResolver.getClassId(classData.getClassProto().getFqName());
+            return context.getClassDeserializer().deserializeClass(classId);
+        }
+        return null;
+    }
 
     @Nullable
     public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDescriptorFinder.kt

@@ -36,7 +36,7 @@ public class JavaDescriptorFinder(
         val lazyJavaPackageFragmentProvider = javaDescriptorResolver.getPackageFragmentProvider() as LazyJavaPackageFragmentProvider
         val c = lazyJavaPackageFragmentProvider.c
         val kotlinJvmBinaryClass = c.kotlinClassFinder.findKotlinClass(kotlinFqNameToJavaFqName(classId.asSingleFqName())) ?: return null
-        return lazyJavaPackageFragmentProvider.resolveKotlinBinaryClass(kotlinJvmBinaryClass)
+        return c.deserializedDescriptorResolver.resolveClass(kotlinJvmBinaryClass)
     }
 
     override fun getClassNames(packageName: FqName): Collection<Name> {

core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java

@@ -22,10 +22,7 @@ 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.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
-import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptorImpl;
-import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -44,22 +41,22 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
     private final DeserializedPackageMemberScope members;
     private final NameResolver nameResolver;
     private final PackageFragmentProvider packageFragmentProvider;
-    private final ModuleDescriptor module;
+    private final DeserializationContext deserializationContext;
 
     public BuiltinsPackageFragment(@NotNull StorageManager storageManager, @NotNull ModuleDescriptor module) {
         super(module, KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);
-        this.module = module;
         nameResolver = NameSerializationUtil.deserializeNameResolver(getStream(BuiltInsSerializationUtil.getNameTableFilePath(getFqName())));
 
         packageFragmentProvider = new BuiltinsPackageFragmentProvider();
 
-        DeserializationContext context = new DeserializationContext(
+        BuiltInsDescriptorFinder descriptorFinder = new BuiltInsDescriptorFinder(storageManager);
-                storageManager, module, new BuiltInsDescriptorFinder(storageManager),
+        deserializationContext = new DeserializationContext(
+                storageManager, module, descriptorFinder,
                 // TODO: support annotations
                 AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider,
-                nameResolver
+                new ClassDeserializer(storageManager, descriptorFinder), nameResolver
         );
-        members = new DeserializedPackageMemberScope(this, loadPackage(), context);
+        members = new DeserializedPackageMemberScope(this, loadPackage(), deserializationContext);
     }
 
     @NotNull
@@ -119,13 +116,11 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
         }
     }
 
-    private class BuiltInsDescriptorFinder extends AbstractDescriptorFinder {
+    private class BuiltInsDescriptorFinder implements DescriptorFinder {
         private final NotNullLazyValue<Collection<Name>> classNames;
 
         public BuiltInsDescriptorFinder(@NotNull StorageManager storageManager) {
             // TODO: support annotations
-            super(storageManager, module, AnnotationLoader.UNSUPPORTED, ConstantLoader.UNSUPPORTED, packageFragmentProvider);
-
             classNames = storageManager.createLazyValue(new Function0<Collection<Name>>() {
                 @Override
                 @NotNull
@@ -154,8 +149,7 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
         }
 
         @Nullable
-        @Override
+        private ClassData getClassData(@NotNull ClassId classId) {
-        protected ClassData getClassData(@NotNull ClassId classId) {
             InputStream stream = getStreamNullable(BuiltInsSerializationUtil.getClassMetadataPath(classId));
             if (stream == null) {
                 return null;
@@ -179,6 +173,13 @@ class BuiltinsPackageFragment extends PackageFragmentDescriptorImpl {
             }
         }
 
+        @Nullable
+        @Override
+        public ClassDescriptor findClass(@NotNull ClassId classId) {
+            ClassData classData = getClassData(classId);
+            return classData == null ? null : new DeserializedClassDescriptor(deserializationContext, classData);
+        }
+
         @NotNull
         @Override
         public Collection<Name> getClassNames(@NotNull FqName packageName) {

core/serialization/src/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorFinder.java

@@ -1,60 +0,0 @@
-/*
- * Copyright 2010-2013 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 kotlin.Function1;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-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.ModuleDescriptor;
-import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
-import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
-import org.jetbrains.jet.storage.StorageManager;
-
-public abstract class AbstractDescriptorFinder implements DescriptorFinder {
-    private final MemoizedFunctionToNullable<ClassId, ClassDescriptor> findClass;
-
-    public AbstractDescriptorFinder(
-            @NotNull StorageManager storageManager,
-            @NotNull ModuleDescriptor moduleDescriptor,
-            @NotNull AnnotationLoader annotationLoader,
-            @NotNull ConstantLoader constantLoader,
-            @NotNull PackageFragmentProvider packageFragmentProvider
-    ) {
-        final DeserializationGlobalContext deserializationGlobalContext =
-                new DeserializationGlobalContext(storageManager, moduleDescriptor, this, annotationLoader, constantLoader,
-                                                 packageFragmentProvider);
-        this.findClass = storageManager.createMemoizedFunctionWithNullableValues(new Function1<ClassId, ClassDescriptor>() {
-            @Override
-            public ClassDescriptor invoke(ClassId classId) {
-                ClassData classData = getClassData(classId);
-                return classData == null ? null : new DeserializedClassDescriptor(deserializationGlobalContext, classData);
-            }
-        });
-    }
-
-    @Nullable
-    @Override
-    public ClassDescriptor findClass(@NotNull ClassId classId) {
-        return findClass.invoke(classId);
-    }
-
-    @Nullable
-    protected abstract ClassData getClassData(@NotNull ClassId classId);
-}

core/serialization/src/org/jetbrains/jet/descriptors/serialization/ClassDeserializer.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.lang.descriptors.ClassDescriptor
+import org.jetbrains.jet.storage.StorageManager
+
+public class ClassDeserializer(val storageManager: StorageManager, val descriptorFinder: DescriptorFinder) {
+    private val classes = storageManager.createMemoizedFunctionWithNullableValues {
+        (classId: ClassId) ->
+        descriptorFinder.findClass(classId)
+    }
+
+    public fun deserializeClass(classId: ClassId): ClassDescriptor? = classes(classId)
+}

core/serialization/src/org/jetbrains/jet/descriptors/serialization/context/context.kt

@@ -31,6 +31,7 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.ConstantLoader
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
 import org.jetbrains.jet.descriptors.serialization.ClassId
+import org.jetbrains.jet.descriptors.serialization.ClassDeserializer
 
 public open class DeserializationGlobalContext(
         public val storageManager: StorageManager,
@@ -38,11 +39,12 @@ public open class DeserializationGlobalContext(
         public val descriptorFinder: DescriptorFinder,
         public val annotationLoader: AnnotationLoader,
         public val constantLoader: ConstantLoader,
-        public val packageFragmentProvider: PackageFragmentProvider
+        public val packageFragmentProvider: PackageFragmentProvider,
+        public val classDeserializer: ClassDeserializer = ClassDeserializer(storageManager, descriptorFinder)
 ) {
     public fun withNameResolver(nameResolver: NameResolver): DeserializationContext {
         return DeserializationContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
-                                      constantLoader, packageFragmentProvider, nameResolver)
+                                      constantLoader, packageFragmentProvider, classDeserializer, nameResolver)
     }
 }
 
@@ -54,9 +56,10 @@ public open class DeserializationContext(
         annotationLoader: AnnotationLoader,
         constantLoader: ConstantLoader,
         packageFragmentProvider: PackageFragmentProvider,
+        classDeserializer: ClassDeserializer,
         public val nameResolver: NameResolver
 ) : DeserializationGlobalContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
-                                 constantLoader, packageFragmentProvider) {
+                                 constantLoader, packageFragmentProvider, classDeserializer) {
     fun withTypes(containingDeclaration: DeclarationDescriptor): DeserializationContextWithTypes {
         val typeDeserializer = TypeDeserializer(this, null, "Deserializer for ${containingDeclaration.getName()}",
                                                 TypeDeserializer.TypeParameterResolver.NONE)
@@ -65,7 +68,7 @@ public open class DeserializationContext(
 
     fun withTypes(containingDeclaration: DeclarationDescriptor, typeDeserializer: TypeDeserializer): DeserializationContextWithTypes {
         return DeserializationContextWithTypes(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
-                                               constantLoader, packageFragmentProvider, 
+                                               constantLoader, packageFragmentProvider, classDeserializer,
                                                nameResolver, containingDeclaration, typeDeserializer)
     }
 
@@ -79,11 +82,12 @@ class DeserializationContextWithTypes(
         annotationLoader: AnnotationLoader,
         constantLoader: ConstantLoader,
         packageFragmentProvider: PackageFragmentProvider,
+        classDeserializer: ClassDeserializer,
         nameResolver: NameResolver,
         val containingDeclaration: DeclarationDescriptor,
         val typeDeserializer: TypeDeserializer
 ) : DeserializationContext(storageManager, moduleDescriptor, descriptorFinder, annotationLoader,
-                           constantLoader, packageFragmentProvider, nameResolver) {
+                           constantLoader, packageFragmentProvider, classDeserializer, nameResolver) {
     val deserializer: MemberDeserializer = MemberDeserializer(this)
 
     public fun childContext(
@@ -106,5 +110,5 @@ class DeserializationContextWithTypes(
 }
 
 fun DeserializationGlobalContext.deserializeClass(classId: ClassId): ClassDescriptor? {
-    return descriptorFinder.findClass(classId)
+    return classDeserializer.deserializeClass(classId)
 }

idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt

@@ -58,7 +58,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
     private val moduleDescriptor =
             ModuleDescriptorImpl(Name.special("<module for building decompiled sources>"), listOf(), PlatformToKotlinClassMap.EMPTY)
 
-    override fun resolveTopLevelClass(classFqName: FqName) = classes(classFqName.toClassId())
+    override fun resolveTopLevelClass(classFqName: FqName) = deserializationContext.classDeserializer.deserializeClass(classFqName.toClassId())
 
     override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor> {
         assert(packageFqName == directoryPackageFqName, "Was called for $packageFqName but only $directoryPackageFqName is expected.")
@@ -95,10 +95,6 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
         }
     }
     private val storageManager = LockBasedStorageManager.NO_LOCKS
-    private val classes = storageManager.createMemoizedFunctionWithNullableValues {
-        (classId: ClassId) ->
-        resolveClassByClassId(classId)
-    }
 
     private val deserializerStorage = DescriptorDeserializersStorage(storageManager);
     {
@@ -123,7 +119,7 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
 
     private val descriptorFinder = object : DescriptorFinder {
         override fun findClass(classId: ClassId): ClassDescriptor? {
-            return classes(classId)
+            return resolveClassByClassId(classId)
         }
 
         override fun getClassNames(packageName: FqName): Collection<Name> {