StorageManager&ExceptionTracker delivered where needed

- GlobalContext introduced to group the two
- Caches track exceptions

idea/src/org/jetbrains/jet/plugin/caches/resolve/JSDeclarationsCacheProvider.java

@@ -77,7 +77,7 @@ class JSDeclarationsCacheProvider extends DeclarationsCacheProvider {
                     project,
                     cachedKey,
                     declarationsProvider,
-                    false
+                    true
             );
         }
     }

idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java

@@ -105,7 +105,7 @@ class JvmDeclarationsCacheProvider extends DeclarationsCacheProvider {
                     project,
                     cachedKey,
                     declarationsProvider,
-                    false
+                    true
             );
         }
     }

idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinDeclarationsCacheImpl.java

@@ -17,11 +17,13 @@
 package org.jetbrains.jet.plugin.caches.resolve;
 
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.ModificationTracker;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
 
-public class KotlinDeclarationsCacheImpl implements KotlinDeclarationsCache {
+public class KotlinDeclarationsCacheImpl implements KotlinDeclarationsCache, ModificationTracker {
 
     private static final Logger LOG = Logger.getInstance(KotlinDeclarationsCacheImpl.class);
 
@@ -40,6 +42,13 @@ public class KotlinDeclarationsCacheImpl implements KotlinDeclarationsCache {
         return exhaust.getBindingContext();
     }
 
+    @Override
+    public long getModificationCount() {
+        BodiesResolveContext context = exhaust.getBodiesResolveContext();
+        if (context == null) return 0;
+        return context.getExceptionTracker().getModificationCount();
+    }
+
     @NotNull
     public AnalyzeExhaust getAnalyzeExhaust() {
         return exhaust;

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

@@ -43,6 +43,8 @@ import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.asJava.LightClassUtil;
 import org.jetbrains.jet.codegen.binding.PsiCodegenPredictor;
 import org.jetbrains.jet.di.InjectorForLazyResolve;
+import org.jetbrains.jet.context.ContextPackage;
+import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -64,7 +66,6 @@ import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex;
 import org.jetbrains.jet.plugin.stubindex.JetTopLevelFunctionsFqnNameIndex;
 import org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex;
-import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -215,8 +216,8 @@ public class JetSourceNavigationHelper {
         }
 
         Project project = decompiledDeclaration.getProject();
-        LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create();
-        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(storageManager, getContainingFiles(candidates),
+        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
+        FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), getContainingFiles(candidates),
                 new Predicate<FqName>() {
                     @Override
                     public boolean apply(@Nullable FqName fqName) {
@@ -231,7 +232,7 @@ public class JetSourceNavigationHelper {
 
         KotlinCodeAnalyzer analyzer = new InjectorForLazyResolve(
                 project,
-                storageManager,
+                globalContext,
                 moduleDescriptor,
                 providerFactory,
                 new BindingTraceContext()).getResolveSession();

idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java

@@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.TypeConstructor;
+import org.jetbrains.jet.storage.ExceptionTracker;
 import org.jetbrains.jet.storage.LazyResolveStorageManager;
 import org.jetbrains.jet.storage.MemoizedFunctionToNotNull;
 import org.jetbrains.jet.storage.StorageManager;
@@ -229,8 +230,7 @@ public class ResolveElementCache {
     private static void delegationSpecifierAdditionalResolve(
             ResolveSession resolveSession,
             JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
-                                                                       trace, file, resolveSession.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file);
 
         JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent();
         LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
@@ -249,6 +249,7 @@ public class ResolveElementCache {
 
         BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy(
                 resolveSession.getStorageManager(),
+                resolveSession.getExceptionTracker(),
                 new Function<JetDeclaration, JetScope>() {
                     @Override
                     public JetScope apply(JetDeclaration declaration) {
@@ -279,8 +280,7 @@ public class ResolveElementCache {
             BindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
-                                                                       trace, file, resolveSession.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file);
         JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction);
         FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction);
         bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope);
@@ -292,8 +292,7 @@ public class ResolveElementCache {
             BindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
-                                                                       trace, file, resolveSession.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file);
         JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass);
 
         ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass);
@@ -309,8 +308,7 @@ public class ResolveElementCache {
             BindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
-                                                                       trace, file, resolveSession.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession, trace, file);
         JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class);
         LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
         bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(),
@@ -323,18 +321,23 @@ public class ResolveElementCache {
             ModuleDescriptor module) {
         TopDownAnalysisParameters parameters = new TopDownAnalysisParameters(
                 bodyResolveContext.getStorageManager(),
+                bodyResolveContext.getExceptionTracker(),
                 Predicates.<PsiFile>alwaysTrue(), false, true, Collections.<AnalyzerScriptParameter>emptyList());
         InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(file.getProject(), parameters, trace, bodyResolveContext, module);
         return bodyResolve.getBodyResolver();
     }
 
     private static BodyResolver createBodyResolverWithEmptyContext(
-            StorageManager storageManager,
+            ResolveSession resolveSession,
             BindingTrace trace,
-            JetFile file,
-            ModuleDescriptor module
+            JetFile file
     ) {
-        return createBodyResolver(trace, file, new BodyResolveContextForLazy(storageManager, Functions.<JetScope>constant(null)), module);
+        return createBodyResolver(trace, file,
+                                  new BodyResolveContextForLazy(
+                                          resolveSession.getStorageManager(),
+                                          resolveSession.getExceptionTracker(),
+                                          Functions.<JetScope>constant(null)),
+                                  resolveSession.getModuleDescriptor());
     }
 
     private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) {
@@ -424,18 +427,30 @@ public class ResolveElementCache {
     private static class BodyResolveContextForLazy implements BodiesResolveContext {
 
         private final StorageManager storageManager;
+        private final ExceptionTracker exceptionTracker;
         private final Function<? super JetDeclaration, JetScope> declaringScopes;
 
-        private BodyResolveContextForLazy(StorageManager storageManager, @NotNull Function<? super JetDeclaration, JetScope> declaringScopes) {
+        private BodyResolveContextForLazy(
+                @NotNull StorageManager storageManager,
+                @NotNull ExceptionTracker exceptionTracker,
+                @NotNull Function<? super JetDeclaration, JetScope> declaringScopes) {
             this.storageManager = storageManager;
+            this.exceptionTracker = exceptionTracker;
             this.declaringScopes = declaringScopes;
         }
 
+        @NotNull
         @Override
         public StorageManager getStorageManager() {
             return storageManager;
         }
 
+        @NotNull
+        @Override
+        public ExceptionTracker getExceptionTracker() {
+            return exceptionTracker;
+        }
+
         @Override
         public Collection<JetFile> getFiles() {
             return Collections.emptySet();

idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java

@@ -34,6 +34,8 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.asJava.LightClassUtil;
+import org.jetbrains.jet.context.ContextPackage;
+import org.jetbrains.jet.context.GlobalContextImpl;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -44,7 +46,6 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.utils.UtilsPackage;
 
 import java.io.File;
@@ -84,8 +85,10 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
         final Runnable initializeRunnable = new Runnable() {
             @Override
             public void run() {
+                GlobalContextImpl globalContext = ContextPackage.GlobalContext();
                 TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                        new LockBasedStorageManager(),
+                        globalContext.getStorageManager(),
+                        globalContext.getExceptionTracker(),
                         Predicates.<PsiFile>alwaysFalse(), true, false, Collections.<AnalyzerScriptParameter>emptyList());
                 ModuleDescriptorImpl module = new ModuleDescriptorImpl(
                         Name.special("<fake_module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);