Resolve sessions use exception tracking from StorageManager

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProviderImpl;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.storage.ExceptionTracker;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
@@ -50,7 +51,7 @@ public class InjectorForJavaDescriptorResolver {
     
     private final Project project;
     private final BindingTrace bindingTrace;
-    private final LockBasedStorageManager lockBasedStorageManager;
+    private final LockBasedStorageManagerWithExceptionTracking storageManager;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
@@ -61,6 +62,7 @@ public class InjectorForJavaDescriptorResolver {
     private final JavaPackageFragmentProviderImpl javaPackageFragmentProvider;
     private final VirtualFileFinder virtualFileFinder;
     private final ModuleDescriptorImpl module;
+    private final ExceptionTracker exceptionTracker;
     private final JavaAnnotationResolver javaAnnotationResolver;
     private final JavaAnnotationArgumentResolver javaAnnotationArgumentResolver;
     private final JavaClassResolver javaClassResolver;
@@ -81,7 +83,8 @@ public class InjectorForJavaDescriptorResolver {
     ) {
         this.project = project;
         this.bindingTrace = bindingTrace;
-        this.lockBasedStorageManager = new LockBasedStorageManager();
+        this.exceptionTracker = new ExceptionTracker();
+        this.storageManager = new LockBasedStorageManagerWithExceptionTracking(exceptionTracker);
         this.javaClassFinder = new JavaClassFinderImpl();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
@@ -96,7 +99,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaAnnotationArgumentResolver = new JavaAnnotationArgumentResolver();
         this.javaClassResolver = new JavaClassResolver();
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(getLockBasedStorageManager());
+        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(getStorageManager());
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaTypeParameterResolver = new JavaTypeParameterResolver();
         this.javaTypeTransformer = new JavaTypeTransformer();
@@ -129,7 +132,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaDescriptorResolver.setModule(module);
         this.javaDescriptorResolver.setPackageFragmentProvider(javaPackageFragmentProvider);
         this.javaDescriptorResolver.setSignatureChecker(psiBasedMethodSignatureChecker);
-        this.javaDescriptorResolver.setStorageManager(lockBasedStorageManager);
+        this.javaDescriptorResolver.setStorageManager(storageManager);
 
         javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache);
         javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
@@ -162,7 +165,7 @@ public class InjectorForJavaDescriptorResolver {
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider);
-        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
+        deserializedDescriptorResolver.setStorageManager(storageManager);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
         annotationDescriptorDeserializer.setJavaDescriptorResolver(javaDescriptorResolver);
@@ -211,8 +214,8 @@ public class InjectorForJavaDescriptorResolver {
     public void destroy() {
     }
     
-    public LockBasedStorageManager getLockBasedStorageManager() {
+    public LockBasedStorageManagerWithExceptionTracking getStorageManager() {
-        return this.lockBasedStorageManager;
+        return this.storageManager;
     }
     
     public JavaClassFinderImpl getJavaClassFinder() {

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

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -100,7 +101,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
         final JavaClassFinderImpl classFinder = injector.getJavaClassFinder();
 
         // TODO: Replace with stub declaration provider
-        LockBasedStorageManager storageManager = injector.getLockBasedStorageManager();
+        LockBasedStorageManagerWithExceptionTracking storageManager = injector.getStorageManager();
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate<FqName>() {
             @Override
             public boolean apply(FqName fqName) {

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

@@ -62,6 +62,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
     };
 
     private final LazyResolveStorageManager storageManager;
+    private final ExceptionTracker exceptionTracker;
 
     private final ModuleDescriptor module;
 
@@ -80,24 +81,30 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
     public ResolveSession(
             @NotNull Project project,
-            @NotNull LockBasedStorageManager storageManager,
+            @NotNull LockBasedStorageManagerWithExceptionTracking storageManager,
             @NotNull ModuleDescriptorImpl rootDescriptor,
             @NotNull DeclarationProviderFactory declarationProviderFactory
     ) {
-        this(project, storageManager, rootDescriptor, declarationProviderFactory, NO_ALIASES,
+        this(project,
+             storageManager,
+             storageManager.getTracker(),
+             rootDescriptor,
+             declarationProviderFactory,
+             NO_ALIASES,
              Predicates.<FqNameUnsafe>alwaysFalse(),
              new BindingTraceContext());
     }
 
     public ResolveSession(
             @NotNull Project project,
-            @NotNull LockBasedStorageManager storageManager,
+            @NotNull LockBasedStorageManagerWithExceptionTracking storageManager,
             @NotNull ModuleDescriptorImpl rootDescriptor,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
             @NotNull BindingTrace delegationTrace
     ) {
         this(project,
              storageManager,
+             storageManager.getTracker(),
              rootDescriptor,
              declarationProviderFactory,
              NO_ALIASES,
@@ -109,6 +116,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
     public ResolveSession(
             @NotNull Project project,
             @NotNull LockBasedStorageManager storageManager,
+            @NotNull ExceptionTracker exceptionTracker,
             @NotNull ModuleDescriptorImpl rootDescriptor,
             @NotNull DeclarationProviderFactory declarationProviderFactory,
             @NotNull Function<FqName, Name> classifierAliases,
@@ -117,6 +125,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
     ) {
         LockBasedLazyResolveStorageManager lockBasedLazyResolveStorageManager = new LockBasedLazyResolveStorageManager(storageManager);
         this.storageManager = lockBasedLazyResolveStorageManager;
+        this.exceptionTracker = exceptionTracker;
         this.classifierAliases = classifierAliases;
         this.specialClasses = specialClasses;
         this.trace = lockBasedLazyResolveStorageManager.createSafeTrace(delegationTrace);
@@ -194,6 +203,11 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         return storageManager;
     }
 
+    @NotNull
+    public ExceptionTracker getExceptionTracker() {
+        return exceptionTracker;
+    }
+
     @Override
     @NotNull
     public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {

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

@@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
 
 import java.io.File;
 import java.io.IOException;
@@ -58,7 +58,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
 
         final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
         lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
-        LockBasedStorageManager storageManager = new LockBasedStorageManager();
+        LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create();
         final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule,
                                                                  new FileBasedDeclarationProviderFactory(storageManager, files));
 

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -44,6 +44,7 @@ import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyI
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
 import org.jetbrains.jet.storage.StorageManager;
 
 import java.io.IOException;
@@ -152,7 +153,7 @@ public class GenerateInjectors {
         generator.addParameter(BindingTrace.class);
 
         // Fields
-        generator.addPublicField(LockBasedStorageManager.class);
+        generator.addField(true, LockBasedStorageManagerWithExceptionTracking.class, "storageManager", null);
         generator.addPublicField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);

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

@@ -63,8 +63,7 @@ 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.LockBasedStorageManager;
+import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
-import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -215,7 +214,7 @@ public class JetSourceNavigationHelper {
         }
 
         Project project = decompiledDeclaration.getProject();
-        LockBasedStorageManager storageManager = new LockBasedStorageManager();
+        LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create();
         FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(storageManager, getContainingFiles(candidates),
                 new Predicate<FqName>() {
                     @Override

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

@@ -16,9 +16,7 @@
 
 package org.jetbrains.jet.plugin.project;
 
-import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.ModificationTracker;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -32,13 +30,10 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 
-import java.util.concurrent.atomic.AtomicLong;
-
 public class CancelableResolveSession implements KotlinCodeAnalyzer, ModificationTracker {
     private final Object createdForObject;
     private final ResolveSession resolveSession;
     private final ResolveElementCache resolveElementCache;
-    private final AtomicLong canceledTracker = new AtomicLong();
 
     public CancelableResolveSession(@NotNull JetFile file, @NotNull ResolveSession resolveSession) {
         this(file, file.getProject(), resolveSession);
@@ -55,82 +50,41 @@ public class CancelableResolveSession implements KotlinCodeAnalyzer, Modificatio
     }
 
     @NotNull
-    public BindingContext resolveToElement(final JetElement element) {
+    public BindingContext resolveToElement(JetElement element) {
-        return computableWithProcessingCancel(new Computable<BindingContext>() {
+        return resolveElementCache.resolveToElement(element);
-            @Override
-            public BindingContext compute() {
-                return resolveElementCache.resolveToElement(element);
-            }
-        });
     }
 
     @Override
     public ModuleDescriptor getModuleDescriptor() {
-        return computableWithProcessingCancel(new Computable<ModuleDescriptor>() {
+        return resolveSession.getModuleDescriptor();
-            @Override
-            public ModuleDescriptor compute() {
-                return resolveSession.getModuleDescriptor();
-            }
-        });
     }
 
     @NotNull
     @Override
-    public ClassDescriptor getClassDescriptor(@NotNull final JetClassOrObject classOrObject) {
+    public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) {
-        return computableWithProcessingCancel(new Computable<ClassDescriptor>() {
+        return resolveSession.getClassDescriptor(classOrObject);
-            @Override
-            public ClassDescriptor compute() {
-                return resolveSession.getClassDescriptor(classOrObject);
-            }
-        });
     }
 
     @NotNull
     @Override
     public BindingContext getBindingContext() {
-        return computableWithProcessingCancel(new Computable<BindingContext>() {
+        return resolveSession.getBindingContext();
-            @Override
-            public BindingContext compute() {
-                return resolveSession.getBindingContext();
-            }
-        });
     }
 
     @NotNull
     @Override
-    public DeclarationDescriptor resolveToDescriptor(final JetDeclaration declaration) {
+    public DeclarationDescriptor resolveToDescriptor(JetDeclaration declaration) {
-        return computableWithProcessingCancel(new Computable<DeclarationDescriptor>() {
+        return resolveSession.resolveToDescriptor(declaration);
-            @Override
-            public DeclarationDescriptor compute() {
-                return resolveSession.resolveToDescriptor(declaration);
-            }
-        });
     }
 
     @Override
     public void forceResolveAll() {
-        computableWithProcessingCancel(new Computable<Integer>() {
+        resolveSession.forceResolveAll();
-            @Override
-            public Integer compute() {
-                resolveSession.forceResolveAll();
-                return 0;
-            }
-        });
-    }
-
-    private <T> T computableWithProcessingCancel(Computable<T> computable) {
-        try {
-            return computable.compute();
-        }
-        catch (ProcessCanceledException canceledException) {
-            canceledTracker.getAndIncrement();
-            throw canceledException;
-        }
     }
 
     @Override
     public long getModificationCount() {
-        return canceledTracker.get();
+        return resolveSession.getExceptionTracker().getModificationCount();
     }
 
     @Override

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

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.LockBasedStorageManagerWithExceptionTracking;
 import org.jetbrains.k2js.config.Config;
 
 import java.util.Collection;
@@ -152,7 +153,7 @@ public final class AnalyzerFacadeForJS {
 
     @NotNull
     public static ResolveSession getLazyResolveSession(Collection<JetFile> files, Config config) {
-        LockBasedStorageManager storageManager = new LockBasedStorageManager();
+        LockBasedStorageManagerWithExceptionTracking storageManager = LockBasedStorageManagerWithExceptionTracking.create();
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                 storageManager, Config.withJsLibAdded(files, config), Predicates.<FqName>alwaysFalse());
         ModuleDescriptorImpl module = createJsModule("<lazy module>");