Declaration providers and resolve session are protected by a storage manager

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java

@@ -37,6 +37,7 @@ import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -90,7 +91,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         final PsiClassFinder psiClassFinder = injector.getPsiClassFinder();
 
         // TODO: Replace with stub declaration provider
-        final FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(files, new Predicate<FqName>() {
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
+        final FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate<FqName>() {
             @Override
             public boolean apply(FqName fqName) {
                 return psiClassFinder.findPsiPackage(fqName) != null || new FqName("jet").equals(fqName);
@@ -136,7 +138,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
 
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
 
-        return new ResolveSession(fileProject, lazyModule, moduleConfiguration, declarationProviderFactory, javaResolverTrace);
+        return new ResolveSession(fileProject, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory, javaResolverTrace);
     }
 
     public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractPsiBasedDeclarationProvider.java

@@ -20,6 +20,7 @@ import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
+import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -30,71 +31,76 @@ import java.util.List;
 import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve;
 
 public abstract class AbstractPsiBasedDeclarationProvider implements DeclarationProvider {
-    private final List<JetDeclaration> allDeclarations = Lists.newArrayList();
-    private final Multimap<Name, JetNamedFunction> functions = HashMultimap.create();
-    private final Multimap<Name, JetProperty> properties = HashMultimap.create();
-    private final Multimap<Name, JetClassOrObject> classesAndObjects = ArrayListMultimap.create(); // order matters here
 
-    private boolean indexCreated = false;
+    protected static class Index {
+        // This mutable state is only modified under inside the computable
+        private final List<JetDeclaration> allDeclarations = Lists.newArrayList();
+        private final Multimap<Name, JetNamedFunction> functions = HashMultimap.create();
+        private final Multimap<Name, JetProperty> properties = HashMultimap.create();
+        private final Multimap<Name, JetClassOrObject> classesAndObjects = ArrayListMultimap.create(); // order matters here
 
-    protected final void createIndex() {
+        public void putToIndex(@NotNull JetDeclaration declaration) {
-        if (indexCreated) return;
+            if (declaration instanceof JetClassInitializer) {
-        indexCreated = true;
+                return;
+            }
+            allDeclarations.add(declaration);
+            if (declaration instanceof JetNamedFunction) {
+                JetNamedFunction namedFunction = (JetNamedFunction) declaration;
+                functions.put(safeNameForLazyResolve(namedFunction), namedFunction);
+            }
+            else if (declaration instanceof JetProperty) {
+                JetProperty property = (JetProperty) declaration;
+                properties.put(safeNameForLazyResolve(property), property);
+            }
+            else if (declaration instanceof JetClassOrObject) {
+                JetClassOrObject classOrObject = (JetClassOrObject) declaration;
+                classesAndObjects.put(safeNameForLazyResolve(classOrObject.getNameAsName()), classOrObject);
+            }
+            else if (declaration instanceof JetParameter || declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) {
+                // Do nothing, just put it into allDeclarations is enough
+            }
+            else {
+                throw new IllegalArgumentException("Unknown declaration: " + declaration);
+            }
+        }
 
-        doCreateIndex();
     }
 
-    protected abstract void doCreateIndex();
+    private final LazyValue<Index> index;
 
-    protected void putToIndex(JetDeclaration declaration) {
+    public AbstractPsiBasedDeclarationProvider(@NotNull StorageManager storageManager) {
-        if (declaration instanceof JetClassInitializer) {
+        index = storageManager.createLazyValue(new Computable<Index>() {
-            return;
+            @Override
-        }
+            public Index compute() {
-        allDeclarations.add(declaration);
+                Index index = new Index();
-        if (declaration instanceof JetNamedFunction) {
+                doCreateIndex(index);
-            JetNamedFunction namedFunction = (JetNamedFunction) declaration;
+                return index;
-            functions.put(safeNameForLazyResolve(namedFunction), namedFunction);
+            }
-        }
+        });
-        else if (declaration instanceof JetProperty) {
-            JetProperty property = (JetProperty) declaration;
-            properties.put(safeNameForLazyResolve(property), property);
-        }
-        else if (declaration instanceof JetClassOrObject) {
-            JetClassOrObject classOrObject = (JetClassOrObject) declaration;
-            classesAndObjects.put(safeNameForLazyResolve(classOrObject.getNameAsName()), classOrObject);
-        }
-        else if (declaration instanceof JetParameter || declaration instanceof JetTypedef || declaration instanceof JetMultiDeclaration) {
-            // Do nothing, just put it into allDeclarations is enough
-        }
-        else {
-            throw new IllegalArgumentException("Unknown declaration: " + declaration);
-        }
     }
 
+    protected abstract void doCreateIndex(@NotNull Index index);
+
     @Override
     public List<JetDeclaration> getAllDeclarations() {
-        createIndex();
+        return index.get().allDeclarations;
-        return allDeclarations;
     }
 
     @NotNull
     @Override
     public List<JetNamedFunction> getFunctionDeclarations(@NotNull Name name) {
-        createIndex();
+        return Lists.newArrayList(index.get().functions.get(name));
-        return Lists.newArrayList(functions.get(name));
     }
 
     @NotNull
     @Override
     public List<JetProperty> getPropertyDeclarations(@NotNull Name name) {
-        createIndex();
+        return Lists.newArrayList(index.get().properties.get(name));
-        return Lists.newArrayList(properties.get(name));
     }
 
     @NotNull
     @Override
     public Collection<JetClassOrObject> getClassOrObjectDeclarations(@NotNull Name name) {
-        createIndex();
+        return index.get().classesAndObjects.get(name);
-        return classesAndObjects.get(name);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/FileBasedDeclarationProviderFactory.java

@@ -18,7 +18,11 @@ package org.jetbrains.jet.lang.resolve.lazy;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-import com.google.common.collect.*;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
@@ -26,56 +30,68 @@ import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.Collection;
-import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
 
 public class FileBasedDeclarationProviderFactory implements DeclarationProviderFactory {
 
-    private final Collection<JetFile> allFiles;
+    private static class Index {
-
+        private final Multimap<FqName, JetFile> filesByPackage = HashMultimap.create();
-    private final Multimap<FqName, JetFile> filesByPackage = HashMultimap.create();
+        private final Set<FqName> declaredPackages = Sets.newHashSet();
-    private final Set<FqName> declaredPackages = Sets.newHashSet();
+    }
-    private final Map<FqName, PackageMemberDeclarationProvider> packageDeclarationProviders = Maps.newHashMap();
 
     private final Predicate<FqName> isPackageDeclaredExternally;
 
-    private boolean indexed = false;
+    private final StorageManager storageManager;
+    private final LazyValue<Index> index;
 
-    public FileBasedDeclarationProviderFactory(@NotNull Collection<JetFile> files) {
+    private final ConcurrentMap<FqName, PackageMemberDeclarationProvider> packageDeclarationProviders;
-        this(files, Predicates.<FqName>alwaysFalse());
+
+    public FileBasedDeclarationProviderFactory(@NotNull StorageManager storageManager, @NotNull Collection<JetFile> files) {
+        this(storageManager, files, Predicates.<FqName>alwaysFalse());
     }
 
-    public FileBasedDeclarationProviderFactory(@NotNull Collection<JetFile> files, Predicate<FqName> isPackageDeclaredExternally) {
+    public FileBasedDeclarationProviderFactory(
-        this.allFiles = files;
+            @NotNull StorageManager storageManager,
+            @NotNull final Collection<JetFile> files,
+            @NotNull Predicate<FqName> isPackageDeclaredExternally
+    ) {
+        this.storageManager = storageManager;
         this.isPackageDeclaredExternally = isPackageDeclaredExternally;
+        this.index = storageManager.createLazyValue(new Computable<Index>() {
+            @Override
+            public Index compute() {
+                return computeFilesByPackage(files);
+            }
+        });
+        this.packageDeclarationProviders = storageManager.createConcurrentMap();
     }
 
-    private void createIndex() {
+    @NotNull
-        if (indexed) return;
+    private static Index computeFilesByPackage(@NotNull Collection<JetFile> files) {
-        indexed = true;
+        Index index = new Index();
-
+        for (JetFile file : files) {
-        for (JetFile file : allFiles) {
             JetNamespaceHeader header = file.getNamespaceHeader();
             if (header == null) {
                 throw new IllegalArgumentException("Scripts are not supported");
             }
 
             FqName packageFqName = new FqName(header.getQualifiedName());
-            addMeAndParentPackages(packageFqName);
+            addMeAndParentPackages(index, packageFqName);
-            filesByPackage.put(packageFqName, file);
+            index.filesByPackage.put(packageFqName, file);
         }
+        return index;
     }
 
-    private void addMeAndParentPackages(@NotNull FqName name) {
+    private static void addMeAndParentPackages(@NotNull Index index, @NotNull FqName name) {
-        declaredPackages.add(name);
+        index.declaredPackages.add(name);
         if (!name.isRoot()) {
-            addMeAndParentPackages(name.parent());
+            addMeAndParentPackages(index, name.parent());
         }
     }
 
     /*package*/ boolean isPackageDeclaredExplicitly(@NotNull FqName packageFqName) {
-        createIndex();
+        return index.get().declaredPackages.contains(packageFqName);
-        return declaredPackages.contains(packageFqName);
     }
 
     /*package*/ boolean isPackageDeclared(@NotNull FqName packageFqName) {
@@ -83,7 +99,7 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF
     }
 
     /*package*/ Collection<FqName> getAllDeclaredSubPackagesOf(@NotNull final FqName parent) {
-        return Collections2.filter(declaredPackages, new Predicate<FqName>() {
+        return Collections2.filter(index.get().declaredPackages, new Predicate<FqName>() {
             @Override
             public boolean apply(FqName fqName) {
                 return !fqName.isRoot() && fqName.parent().equals(parent);
@@ -93,8 +109,6 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF
 
     @Override
     public PackageMemberDeclarationProvider getPackageMemberDeclarationProvider(@NotNull FqName packageFqName) {
-        createIndex();
-
         PackageMemberDeclarationProvider declarationProvider = packageDeclarationProviders.get(packageFqName);
         if (declarationProvider != null) {
             return declarationProvider;
@@ -108,21 +122,18 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF
         }
 
         FileBasedPackageMemberDeclarationProvider provider =
-                new FileBasedPackageMemberDeclarationProvider(packageFqName, this, filesByPackage.get(packageFqName));
+                new FileBasedPackageMemberDeclarationProvider(storageManager, packageFqName, this, index.get().filesByPackage.get(packageFqName));
-        packageDeclarationProviders.put(packageFqName, provider);
 
-        return provider;
+        return packageDeclarationProviders.putIfAbsent(packageFqName, provider);
     }
 
     @NotNull
     @Override
     public ClassMemberDeclarationProvider getClassMemberDeclarationProvider(@NotNull JetClassLikeInfo classLikeInfo) {
-        createIndex();
+        if (!index.get().filesByPackage.containsKey(classLikeInfo.getContainingPackageFqName())) {
-
-        if (!filesByPackage.containsKey(classLikeInfo.getContainingPackageFqName())) {
             throw new IllegalStateException("This factory doesn't know about this class: " + classLikeInfo);
         }
 
-        return new PsiBasedClassMemberDeclarationProvider(classLikeInfo);
+        return new PsiBasedClassMemberDeclarationProvider(storageManager, classLikeInfo);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/FileBasedPackageMemberDeclarationProvider.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.lazy;
 
+import com.intellij.openapi.util.Computable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -28,24 +29,32 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD
     private final FqName fqName;
     private final FileBasedDeclarationProviderFactory factory;
     private final Collection<JetFile> allFiles;
-    private Collection<FqName> allDeclaredPackages;
+    private final LazyValue<Collection<FqName>> allDeclaredPackages;
 
 
     /*package*/ FileBasedPackageMemberDeclarationProvider(
-            @NotNull FqName fqName,
+            @NotNull StorageManager storageManager,
-            @NotNull FileBasedDeclarationProviderFactory factory,
+            @NotNull FqName _fqName,
+            @NotNull FileBasedDeclarationProviderFactory _factory,
             @NotNull Collection<JetFile> allFiles
     ) {
-        this.fqName = fqName;
+        super(storageManager);
-        this.factory = factory;
+        this.fqName = _fqName;
+        this.factory = _factory;
         this.allFiles = allFiles;
+        this.allDeclaredPackages = storageManager.createLazyValue(new Computable<Collection<FqName>>() {
+            @Override
+            public Collection<FqName> compute() {
+                return factory.getAllDeclaredSubPackagesOf(fqName);
+            }
+        });
     }
 
     @Override
-    protected void doCreateIndex() {
+    protected void doCreateIndex(@NotNull Index index) {
         for (JetFile file : allFiles) {
             for (JetDeclaration declaration : file.getDeclarations()) {
-                putToIndex(declaration);
+                index.putToIndex(declaration);
             }
         }
     }
@@ -57,10 +66,7 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD
 
     @Override
     public Collection<FqName> getAllDeclaredPackages() {
-        if (allDeclaredPackages == null) {
+        return allDeclaredPackages.get();
-            allDeclaredPackages = factory.getAllDeclaredSubPackagesOf(fqName);
-        }
-        return allDeclaredPackages;
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/PsiBasedClassMemberDeclarationProvider.java

@@ -24,7 +24,8 @@ public class PsiBasedClassMemberDeclarationProvider extends AbstractPsiBasedDecl
 
     private final JetClassLikeInfo classInfo;
 
-    public PsiBasedClassMemberDeclarationProvider(@NotNull JetClassLikeInfo classInfo) {
+    public PsiBasedClassMemberDeclarationProvider(@NotNull StorageManager storageManager, @NotNull JetClassLikeInfo classInfo) {
+        super(storageManager);
         this.classInfo = classInfo;
     }
 
@@ -35,19 +36,19 @@ public class PsiBasedClassMemberDeclarationProvider extends AbstractPsiBasedDecl
     }
 
     @Override
-    protected void doCreateIndex() {
+    protected void doCreateIndex(@NotNull Index index) {
         for (JetDeclaration declaration : classInfo.getDeclarations()) {
             if (declaration instanceof JetClassObject) {
                 // Do nothing, class object will be taken directly from the classInfo
             }
             else {
-                putToIndex(declaration);
+                index.putToIndex(declaration);
             }
         }
 
         for (JetParameter parameter : classInfo.getPrimaryConstructorParameters()) {
             if (parameter.getValOrVarNode() != null) {
-                putToIndex(parameter);
+                index.putToIndex(parameter);
             }
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java

@@ -65,23 +65,26 @@ public class ResolveSession {
 
     public ResolveSession(
         @NotNull Project project,
+        @NotNull StorageManager storageManager,
         @NotNull ModuleDescriptor rootDescriptor,
         @NotNull ModuleConfiguration moduleConfiguration,
         @NotNull DeclarationProviderFactory declarationProviderFactory
     ) {
-        this(project, rootDescriptor, moduleConfiguration, declarationProviderFactory, NO_ALIASES,
+        this(project, storageManager, rootDescriptor, moduleConfiguration, declarationProviderFactory, NO_ALIASES,
              Predicates.<FqNameUnsafe>alwaysFalse(),
              new BindingTraceContext());
     }
 
     public ResolveSession(
             @NotNull Project project,
+            @NotNull StorageManager storageManager,
             @NotNull ModuleDescriptor rootDescriptor,
             @NotNull ModuleConfiguration moduleConfiguration,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
             @NotNull BindingTrace delegationTrace
     ) {
         this(project,
+             storageManager,
              rootDescriptor,
              moduleConfiguration,
              declarationProviderFactory,
@@ -93,6 +96,7 @@ public class ResolveSession {
     @Deprecated // Internal use only
     public ResolveSession(
             @NotNull Project project,
+            @NotNull StorageManager storageManager,
             @NotNull ModuleDescriptor rootDescriptor,
             @NotNull ModuleConfiguration moduleConfiguration,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
@@ -100,7 +104,7 @@ public class ResolveSession {
             @NotNull Predicate<FqNameUnsafe> specialClasses,
             @NotNull BindingTrace delegationTrace
     ) {
-        this.storageManager = new LockBasedStorageManager();
+        this.storageManager = storageManager;
         this.classifierAliases = classifierAliases;
         this.specialClasses = specialClasses;
         this.trace = new ObservableBindingTrace(delegationTrace);

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java

@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -221,11 +222,13 @@ public class KotlinBuiltIns {
     @NotNull
     private ResolveSession createLazyResolveSession(@NotNull Project project) throws IOException {
         List<JetFile> files = loadResourcesAsJetFiles(project, LIBRARY_FILES);
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
         return new ResolveSession(
                 project,
+                storageManager,
                 builtInsModule,
                 new SpecialModuleConfiguration(project),
-                new FileBasedDeclarationProviderFactory(files),
+                new FileBasedDeclarationProviderFactory(storageManager, files),
                 new Function<FqName, Name>() {
                     @Override
                     public Name fun(FqName name) {

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -53,8 +53,9 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         Collection<JetFile> files = Lists.newArrayList(psiFile);
 
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
-        final ResolveSession resolveSession = new ResolveSession(getProject(), lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
-                                                    new FileBasedDeclarationProviderFactory(files));
+        final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
+                                                    new FileBasedDeclarationProviderFactory(storageManager, files));
 
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
         psiFile.accept(new JetVisitorVoid() {

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -92,7 +92,8 @@ public class LazyResolveTestUtil {
         final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
 
-        final FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(files, new Predicate<FqName>() {
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
+        final FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate<FqName>() {
             @Override
             public boolean apply(FqName fqName) {
                 return psiClassFinder.findPsiPackage(fqName) != null || new FqName("jet").equals(fqName);
@@ -134,7 +135,7 @@ public class LazyResolveTestUtil {
 
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
         ResolveSession
-                session = new ResolveSession(project, lazyModule, moduleConfiguration, declarationProviderFactory);
+                session = new ResolveSession(project, storageManager, lazyModule, moduleConfiguration, declarationProviderFactory);
         return lazyModule;
     }
 

idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -198,7 +199,8 @@ public class JetSourceNavigationHelper {
         }
 
         Project project = decompiledDeclaration.getProject();
-        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(getContainingFiles(candidates),
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
+        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(storageManager, getContainingFiles(candidates),
                 new Predicate<FqName>() {
                     @Override
                     public boolean apply(@Nullable FqName fqName) {
@@ -207,6 +209,7 @@ public class JetSourceNavigationHelper {
                 });
         ResolveSession resolveSession = new ResolveSession(
                 project,
+                storageManager,
                 new ModuleDescriptor(Name.special("<library module>")),
                 DefaultModuleConfiguration.createStandardConfiguration(project),
                 providerFactory);

idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubDeclarationProviderFactory.java

@@ -19,10 +19,7 @@ package org.jetbrains.jet.plugin.stubindex.resolve;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.lazy.ClassMemberDeclarationProvider;
+import org.jetbrains.jet.lang.resolve.lazy.*;
-import org.jetbrains.jet.lang.resolve.lazy.DeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.lazy.PackageMemberDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.lazy.PsiBasedClassMemberDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
@@ -30,16 +27,18 @@ public class StubDeclarationProviderFactory implements DeclarationProviderFactor
 
     private final Project project;
     private final GlobalSearchScope searchScope;
+    private final StorageManager storageManager;
 
-    public StubDeclarationProviderFactory(@NotNull Project project, @NotNull GlobalSearchScope scope) {
+    public StubDeclarationProviderFactory(@NotNull Project project, @NotNull GlobalSearchScope scope, @NotNull StorageManager manager) {
         this.project = project;
         searchScope = scope;
+        storageManager = manager;
     }
 
     @NotNull
     @Override
     public ClassMemberDeclarationProvider getClassMemberDeclarationProvider(@NotNull JetClassLikeInfo classLikeInfo) {
-        return new PsiBasedClassMemberDeclarationProvider(classLikeInfo);
+        return new PsiBasedClassMemberDeclarationProvider(storageManager, classLikeInfo);
     }
 
     @Override

js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.lazy.LockBasedStorageManager;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -139,9 +140,10 @@ public final class AnalyzerFacadeForJS {
 
     @NotNull
     public static ResolveSession getLazyResolveSession(Collection<JetFile> files, final Config config) {
+        LockBasedStorageManager storageManager = new LockBasedStorageManager();
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
-                Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
+                storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
-        return new ResolveSession(config.getProject(), lazyModule, new JsConfiguration(config.getProject(), null), declarationProviderFactory);
+        return new ResolveSession(config.getProject(), storageManager, lazyModule, new JsConfiguration(config.getProject(), null), declarationProviderFactory);
     }
 }