Components across the project use StorageManager

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -43,7 +43,6 @@ import org.jetbrains.jet.codegen.KotlinCodegenFacade;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
-import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy;
@@ -60,6 +59,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.lang.InlineUtil;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetLanguage;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.utils.ExceptionUtils;
 
 import java.io.File;
@@ -102,6 +102,7 @@ public class ReplInterpreter {
         trace = new BindingTraceContext();
         module = AnalyzerFacadeForJVM.createJavaModule("<repl>");
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
+                new LockBasedStorageManager(),
                 Predicates.<PsiFile>alwaysTrue(),
                 false,
                 true,

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

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
@@ -82,7 +82,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final ControlFlowAnalyzer controlFlowAnalyzer;
     private final DeclarationsChecker declarationsChecker;
     private final DescriptorResolver descriptorResolver;
-    private final LockBasedStorageManager storageManager;
+    private final StorageManager storageManager;
     private final CallResolverExtensionProvider callResolverExtensionProvider;
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
@@ -143,7 +143,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.descriptorResolver = new DescriptorResolver();
-        this.storageManager = new LockBasedStorageManager();
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
@@ -164,7 +164,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.expressionTypingServices = new ExpressionTypingServices(storageManager, javaToKotlinClassMap);
         this.callExpressionResolver = new CallExpressionResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -225,6 +225,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        this.descriptorResolver.setStorageManager(storageManager);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
@@ -283,7 +284,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
         expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        expressionTypingServices.setPlatformToKotlinClassMap(javaToKotlinClassMap);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 

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

@@ -40,6 +40,7 @@ import org.jetbrains.jet.storage.LockBasedLazyResolveStorageManager;
 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 java.util.Collection;
 import java.util.Collections;
@@ -200,7 +201,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
             ModuleDescriptorImpl module
     ) {
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                filesToAnalyzeCompletely, false, false, scriptParameters);
+                new LockBasedStorageManager(), filesToAnalyzeCompletely, false, false, scriptParameters);
 
         InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
         try {

compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java

@@ -38,7 +38,7 @@ public class AnalyzerFacadeForEverything {
             @NotNull ModuleDescriptor module) {
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                filesToAnalyzeCompletely, false, false, scriptParameters);
+                bodiesResolveContext.getStorageManager(), filesToAnalyzeCompletely, false, false, scriptParameters);
 
         bodiesResolveContext.setTopDownAnalysisParameters(topDownAnalysisParameters);
 

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

@@ -20,6 +20,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.FunctionAnalyzerExtension;
+import org.jetbrains.jet.storage.StorageManager;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -49,6 +50,7 @@ public class InjectorForBodyResolve {
     private final CallResolverExtensionProvider callResolverExtensionProvider;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
+    private final StorageManager storageManager;
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
     private final BindingTrace bindingTrace;
@@ -80,6 +82,7 @@ public class InjectorForBodyResolve {
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
         this.bindingTrace = bindingTrace;
@@ -88,7 +91,7 @@ public class InjectorForBodyResolve {
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap);
         this.callExpressionResolver = new CallExpressionResolver();
         this.descriptorResolver = new DescriptorResolver();
         this.delegatedPropertyResolver = new DelegatedPropertyResolver();
@@ -130,7 +133,6 @@ public class InjectorForBodyResolve {
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
         expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        expressionTypingServices.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
@@ -139,6 +141,7 @@ public class InjectorForBodyResolve {
         descriptorResolver.setAnnotationResolver(annotationResolver);
         descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        descriptorResolver.setStorageManager(storageManager);
         descriptorResolver.setTypeResolver(typeResolver);
 
         delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);

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

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -51,6 +52,7 @@ public class InjectorForLazyResolve {
     private final JetImportsFactory jetImportsFactory;
     private final CallResolverExtensionProvider callResolverExtensionProvider;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final StorageManager storageManager;
     private final DelegatedPropertyResolver delegatedPropertyResolver;
     private final CallExpressionResolver callExpressionResolver;
     private final CallResolver callResolver;
@@ -66,14 +68,15 @@ public class InjectorForLazyResolve {
         this.resolveSession = resolveSession;
         this.moduleDescriptor = moduleDescriptor;
         this.descriptorResolver = new DescriptorResolver();
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.storageManager = resolveSession.getStorageManager();
+        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap);
         this.typeResolver = new TypeResolver();
         this.scopeProvider = new ScopeProvider(resolveSession);
         this.annotationResolver = new AnnotationResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
         this.jetImportsFactory = new JetImportsFactory();
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.delegatedPropertyResolver = new DelegatedPropertyResolver();
         this.callExpressionResolver = new CallExpressionResolver();
         this.callResolver = new CallResolver();
@@ -83,6 +86,7 @@ public class InjectorForLazyResolve {
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        this.descriptorResolver.setStorageManager(storageManager);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
         this.expressionTypingServices.setAnnotationResolver(annotationResolver);
@@ -90,7 +94,6 @@ public class InjectorForLazyResolve {
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
         this.expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        this.expressionTypingServices.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 

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

@@ -18,6 +18,7 @@ package org.jetbrains.jet.di;
 
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -38,6 +39,7 @@ public class InjectorForMacros {
     
     private final ExpressionTypingServices expressionTypingServices;
     private final CallResolverExtensionProvider callResolverExtensionProvider;
+    private final LockBasedStorageManager lockBasedStorageManager;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
     private final ModuleDescriptor moduleDescriptor;
@@ -55,9 +57,10 @@ public class InjectorForMacros {
         @NotNull Project project,
         @NotNull ModuleDescriptor moduleDescriptor
     ) {
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.lockBasedStorageManager = new LockBasedStorageManager();
-        this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.expressionTypingServices = new ExpressionTypingServices(lockBasedStorageManager, platformToKotlinClassMap);
+        this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.project = project;
         this.moduleDescriptor = moduleDescriptor;
         this.annotationResolver = new AnnotationResolver();
@@ -75,7 +78,6 @@ public class InjectorForMacros {
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
         this.expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        this.expressionTypingServices.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 
@@ -101,6 +103,7 @@ public class InjectorForMacros {
         descriptorResolver.setAnnotationResolver(annotationResolver);
         descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        descriptorResolver.setStorageManager(lockBasedStorageManager);
         descriptorResolver.setTypeResolver(typeResolver);
 
         delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);

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

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
@@ -61,7 +61,7 @@ public class InjectorForTopDownAnalyzerBasic {
     private final ControlFlowAnalyzer controlFlowAnalyzer;
     private final DeclarationsChecker declarationsChecker;
     private final DescriptorResolver descriptorResolver;
-    private final LockBasedStorageManager storageManager;
+    private final StorageManager storageManager;
     private final CallResolverExtensionProvider callResolverExtensionProvider;
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
@@ -102,7 +102,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.descriptorResolver = new DescriptorResolver();
-        this.storageManager = new LockBasedStorageManager();
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
@@ -115,7 +115,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap);
         this.callExpressionResolver = new CallExpressionResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -163,6 +163,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        this.descriptorResolver.setStorageManager(storageManager);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
@@ -188,7 +189,6 @@ public class InjectorForTopDownAnalyzerBasic {
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
         expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        expressionTypingServices.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 

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

@@ -27,11 +27,13 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
 import java.util.Map;
 
 public interface BodiesResolveContext {
+    StorageManager getStorageManager();
     Collection<JetFile> getFiles();
     Map<JetClassOrObject, MutableClassDescriptor> getClasses();
     Map<JetProperty, PropertyDescriptor> getProperties();

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

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -62,6 +63,11 @@ public class CachedBodiesResolveContext implements BodiesResolveContext {
         topDownAnalysisParameters = context.getTopDownAnalysisParameters();
     }
 
+    @Override
+    public StorageManager getStorageManager() {
+        return topDownAnalysisParameters.getStorageManager();
+    }
+
     @Override
     public Collection<JetFile> getFiles() {
         return files;

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

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
+import org.jetbrains.jet.storage.StorageManager;
 
 import javax.inject.Inject;
 import java.io.PrintStream;
@@ -118,6 +119,11 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
         return packageFragments;
     }
 
+    @Override
+    public StorageManager getStorageManager() {
+        return topDownAnalysisParameters.getStorageManager();
+    }
+
     @Override
     public Collection<JetFile> getFiles() {
         return packageFragments.keySet();

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve;
 import com.google.common.base.Predicate;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.List;
 
@@ -26,6 +27,8 @@ import java.util.List;
  * Various junk that cannot be placed into context (yet).
  */
 public class TopDownAnalysisParameters {
+    @NotNull
+    private final StorageManager storageManager;
     @NotNull
     private final Predicate<PsiFile> analyzeCompletely;
     private final boolean analyzingBootstrapLibrary;
@@ -34,16 +37,24 @@ public class TopDownAnalysisParameters {
     private final List<AnalyzerScriptParameter> scriptParameters;
 
     public TopDownAnalysisParameters(
+            @NotNull StorageManager storageManager,
             @NotNull Predicate<PsiFile> analyzeCompletely,
             boolean analyzingBootstrapLibrary,
             boolean declaredLocally,
-            @NotNull List<AnalyzerScriptParameter> scriptParameters) {
+            @NotNull List<AnalyzerScriptParameter> scriptParameters
+    ) {
+        this.storageManager = storageManager;
         this.analyzeCompletely = analyzeCompletely;
         this.analyzingBootstrapLibrary = analyzingBootstrapLibrary;
         this.declaredLocally = declaredLocally;
         this.scriptParameters = scriptParameters;
     }
 
+    @NotNull
+    public StorageManager getStorageManager() {
+        return storageManager;
+    }
+
     @NotNull
     public Predicate<PsiFile> getAnalyzeCompletely() {
         return analyzeCompletely;

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

@@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.storage.StorageManager;
 
 import javax.inject.Inject;
 import java.util.Collection;
@@ -158,6 +159,7 @@ public class TopDownAnalyzer {
     }
 
     public static void processClassOrObject(
+            @NotNull StorageManager storageManager,
             @Nullable final WritableScope scope,
             @NotNull ExpressionTypingContext context,
             @NotNull final DeclarationDescriptor containingDeclaration,
@@ -168,7 +170,7 @@ public class TopDownAnalyzer {
                                                                          PlatformToKotlinClassMap.EMPTY);
 
         TopDownAnalysisParameters topDownAnalysisParameters =
-                new TopDownAnalysisParameters(Predicates.equalTo(object.getContainingFile()),
+                new TopDownAnalysisParameters(storageManager, Predicates.equalTo(object.getContainingFile()),
                 false, true, Collections.<AnalyzerScriptParameter>emptyList());
 
         InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java

@@ -90,7 +90,8 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         };
         ObservableBindingTrace traceAdapter = new ObservableBindingTrace(temporaryTrace);
         traceAdapter.addHandler(CLASS, handler);
-        TopDownAnalyzer.processClassOrObject(null, // don't need to add classifier of object literal to any scope
+        TopDownAnalyzer.processClassOrObject(storageManager,
+                                             null, // don't need to add classifier of object literal to any scope
                                              context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT),
                                              context.scope.getContainingDeclaration(),
                                              expression.getObjectDeclaration());

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java

@@ -137,12 +137,6 @@ public class ExpressionTypingServices {
         this.annotationResolver = annotationResolver;
     }
 
-    @Inject
-    public void setPlatformToKotlinClassMap(@NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
-        this.platformToKotlinClassMap = platformToKotlinClassMap;
-        this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(storageManager, platformToKotlinClassMap);
-    }
-
     @NotNull
     public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
         return platformToKotlinClassMap;
@@ -153,9 +147,13 @@ public class ExpressionTypingServices {
         this.extensionProvider = extensionProvider;
     }
 
-    @Inject
+    public ExpressionTypingServices(
-    public void setStorageManager(@NotNull StorageManager storageManager) {
+            @NotNull StorageManager storageManager,
+            @NotNull PlatformToKotlinClassMap platformToKotlinClassMap
+    ) {
         this.storageManager = storageManager;
+        this.platformToKotlinClassMap = platformToKotlinClassMap;
+        this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(storageManager, platformToKotlinClassMap);
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorDispatcher.java

@@ -48,6 +48,7 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
         return new ExpressionTypingVisitorDispatcher(storageManager, platformToKotlinClassMap, writableScope);
     }
 
+    private final StorageManager storageManager;
     private final BasicExpressionTypingVisitor basic;
     private final ExpressionTypingVisitorForStatements statements;
     private final ClosureExpressionsTypingVisitor closures;
@@ -55,14 +56,15 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
     private final PatternMatchingTypingVisitor patterns = new PatternMatchingTypingVisitor(this);
 
     private ExpressionTypingVisitorDispatcher(StorageManager storageManager, PlatformToKotlinClassMap platformToKotlinClassMap, WritableScope writableScope) {
+        this.storageManager = storageManager;
         this.basic = new BasicExpressionTypingVisitor(this, platformToKotlinClassMap);
         if (writableScope != null) {
-            this.statements = new ExpressionTypingVisitorForStatements(this, writableScope, basic, controlStructures, patterns);
+            this.statements = new ExpressionTypingVisitorForStatements(storageManager, this, writableScope, basic, controlStructures, patterns);
         }
         else {
             this.statements = null;
         }
-        closures = new ClosureExpressionsTypingVisitor(this, storageManager);
+        this.closures = new ClosureExpressionsTypingVisitor(this, storageManager);
     }
 
     @NotNull
@@ -98,7 +100,9 @@ public class ExpressionTypingVisitorDispatcher extends JetVisitor<JetTypeInfo, E
     }
     
     private ExpressionTypingVisitorForStatements createStatementVisitor(ExpressionTypingContext context) {
-        return new ExpressionTypingVisitorForStatements(this, ExpressionTypingUtils.newWritableScopeImpl(context, "statement scope"), basic, controlStructures, patterns);
+        return new ExpressionTypingVisitorForStatements(storageManager, this,
+                                                        ExpressionTypingUtils.newWritableScopeImpl(context, "statement scope"),
+                                                        basic, controlStructures, patterns);
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.types.JetTypeInfo;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
 
@@ -51,18 +52,21 @@ import static org.jetbrains.jet.lang.types.TypeUtils.noExpectedType;
 
 @SuppressWarnings("SuspiciousMethodCalls")
 public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisitor {
+    private final StorageManager storageManager;
     private final WritableScope scope;
     private final BasicExpressionTypingVisitor basic;
     private final ControlStructureTypingVisitor controlStructures;
     private final PatternMatchingTypingVisitor patterns;
 
     public ExpressionTypingVisitorForStatements(
+            @NotNull StorageManager storageManager,
             @NotNull ExpressionTypingInternals facade,
             @NotNull WritableScope scope,
             BasicExpressionTypingVisitor basic,
             @NotNull ControlStructureTypingVisitor controlStructures,
             @NotNull PatternMatchingTypingVisitor patterns) {
         super(facade);
+        this.storageManager = storageManager;
         this.scope = scope;
         this.basic = basic;
         this.controlStructures = controlStructures;
@@ -86,6 +90,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     @Override
     public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
         TopDownAnalyzer.processClassOrObject(
+                storageManager,
                 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration);
         return DataFlowUtils.checkStatementType(declaration, context, context.dataFlowInfo);
     }
@@ -180,6 +185,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     @Override
     public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
         TopDownAnalyzer.processClassOrObject(
+                storageManager,
                 scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass);
         return DataFlowUtils.checkStatementType(klass, context, context.dataFlowInfo);
     }

compiler/tests/org/jetbrains/jet/di/InjectorForTests.java

@@ -21,6 +21,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import com.intellij.openapi.project.Project;
@@ -42,6 +43,7 @@ public class InjectorForTests {
     private final TypeResolver typeResolver;
     private final CallResolver callResolver;
     private final CallResolverExtensionProvider callResolverExtensionProvider;
+    private final LockBasedStorageManager lockBasedStorageManager;
     private final KotlinBuiltIns kotlinBuiltIns;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final Project project;
@@ -58,12 +60,13 @@ public class InjectorForTests {
         @NotNull ModuleDescriptor moduleDescriptor
     ) {
         this.descriptorResolver = new DescriptorResolver();
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.lockBasedStorageManager = new LockBasedStorageManager();
+        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.expressionTypingServices = new ExpressionTypingServices(lockBasedStorageManager, platformToKotlinClassMap);
         this.typeResolver = new TypeResolver();
         this.callResolver = new CallResolver();
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.kotlinBuiltIns = KotlinBuiltIns.getInstance();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.project = project;
         this.moduleDescriptor = moduleDescriptor;
         this.annotationResolver = new AnnotationResolver();
@@ -76,6 +79,7 @@ public class InjectorForTests {
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        this.descriptorResolver.setStorageManager(lockBasedStorageManager);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
         this.expressionTypingServices.setAnnotationResolver(annotationResolver);
@@ -83,7 +87,6 @@ public class InjectorForTests {
         this.expressionTypingServices.setCallResolver(callResolver);
         this.expressionTypingServices.setDescriptorResolver(descriptorResolver);
         this.expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        this.expressionTypingServices.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java

@@ -35,6 +35,7 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClass
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
 import org.junit.Assert;
@@ -141,7 +142,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
                 environment.getProject(),
                 new TopDownAnalysisParameters(
-                        Predicates.<PsiFile>alwaysFalse(), false, false, Collections.<AnalyzerScriptParameter>emptyList()),
+                        new LockBasedStorageManager(), Predicates.<PsiFile>alwaysFalse(), false, false, Collections.<AnalyzerScriptParameter>emptyList()),
                 trace,
                 module);
 

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

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 
 import java.util.Collections;
 import java.util.List;
@@ -53,7 +54,7 @@ public class LazyResolveTestUtil {
         JetTestUtils.newTrace(environment);
 
         TopDownAnalysisParameters params = new TopDownAnalysisParameters(
-                Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
+                new LockBasedStorageManager(), Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
         CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
         BindingTrace sharedTrace = support.getTrace();
         ModuleDescriptorImpl sharedModule = support.getModule();

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

@@ -26,7 +26,6 @@ import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.di.DependencyInjectorGenerator;
 import org.jetbrains.jet.di.GivenExpression;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
-import org.jetbrains.jet.di.InstantiateType;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
@@ -98,6 +97,7 @@ public class GenerateInjectors {
         generator.addPublicField(JetImportsFactory.class);
         generator.addField(CallResolverExtensionProvider.class);
         generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
+        generator.addField(false, StorageManager.class, null, new GivenExpression("resolveSession.getStorageManager()"));
         generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", GenerateInjectors.class);
         return generator;
     }
@@ -179,7 +179,7 @@ public class GenerateInjectors {
         generator.addPublicField(ControlFlowAnalyzer.class);
         generator.addPublicField(DeclarationsChecker.class);
         generator.addPublicField(DescriptorResolver.class);
-        generator.addField(false, StorageManager.class, null, new InstantiateType(LockBasedStorageManager.class));
+        generator.addField(false, StorageManager.class, null, new GivenExpression("topDownAnalysisParameters.getStorageManager()"));
         generator.addField(CallResolverExtensionProvider.class);
 
         // Parameters
@@ -196,6 +196,7 @@ public class GenerateInjectors {
         // Fields
         generator.addPublicField(ExpressionTypingServices.class);
         generator.addField(CallResolverExtensionProvider.class);
+        generator.addField(LockBasedStorageManager.class);
         generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
 
         // Parameters
@@ -215,6 +216,7 @@ public class GenerateInjectors {
         generator.addPublicField(TypeResolver.class);
         generator.addPublicField(CallResolver.class);
         generator.addField(CallResolverExtensionProvider.class);
+        generator.addField(LockBasedStorageManager.class);
         generator.addField(true, KotlinBuiltIns.class, null, new GivenExpression("KotlinBuiltIns.getInstance()"));
         generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
 
@@ -256,6 +258,7 @@ public class GenerateInjectors {
         generator.addField(CallResolverExtensionProvider.class);
         generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"));
         generator.addField(FunctionAnalyzerExtension.class);
+        generator.addField(false, StorageManager.class, null, new GivenExpression("topDownAnalysisParameters.getStorageManager()"));
 
         // Parameters
         generator.addPublicParameter(Project.class);

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

@@ -43,14 +43,13 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.storage.LazyResolveStorageManager;
 import org.jetbrains.jet.storage.MemoizedFunctionToNotNull;
+import org.jetbrains.jet.storage.StorageManager;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
 
 public class ResolveElementCache {
-    private static final BodyResolveContextForLazy EMPTY_CONTEXT = new BodyResolveContextForLazy(Functions.<JetScope>constant(null));
-
     private final CachedValue<MemoizedFunctionToNotNull<JetElement, BindingContext>> additionalResolveCache;
     private final ResolveSession resolveSession;
 
@@ -225,12 +224,13 @@ public class ResolveElementCache {
     }
 
     private static void delegationSpecifierAdditionalResolve(
-            KotlinCodeAnalyzer analyzer,
+            ResolveSession resolveSession,
             JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
+                                                                       trace, file, resolveSession.getModuleDescriptor());
 
         JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent();
-        LazyClassDescriptor descriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject);
+        LazyClassDescriptor descriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
 
         // Activate resolving of supertypes
         descriptor.getTypeConstructor().getSupertypes();
@@ -245,13 +245,16 @@ public class ResolveElementCache {
         final JetScope propertyResolutionScope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(
                 jetProperty);
 
-        BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy(new Function<JetDeclaration, JetScope>() {
+        BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy(
-            @Override
+                resolveSession.getStorageManager(),
-            public JetScope apply(JetDeclaration declaration) {
+                new Function<JetDeclaration, JetScope>() {
-                assert declaration.getParent() == jetProperty : "Must be called only for property accessors, but called for " + declaration;
+                    @Override
-                return propertyResolutionScope;
+                    public JetScope apply(JetDeclaration declaration) {
-            }
+                        assert declaration.getParent() == jetProperty : "Must be called only for property accessors, but called for " +
-        });
+                                                                        declaration;
+                        return propertyResolutionScope;
+                    }
+                });
         BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getModuleDescriptor());
         PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty);
 
@@ -274,7 +277,8 @@ public class ResolveElementCache {
             BindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
+                                                                       trace, file, resolveSession.getModuleDescriptor());
         JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(namedFunction);
         FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction);
         bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope);
@@ -286,7 +290,8 @@ public class ResolveElementCache {
             BindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
+                                                                       trace, file, resolveSession.getModuleDescriptor());
         JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(klass);
 
         ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass);
@@ -297,14 +302,15 @@ public class ResolveElementCache {
     }
 
     private static boolean initializerAdditionalResolve(
-            KotlinCodeAnalyzer analyzer,
+            ResolveSession resolveSession,
             JetClassInitializer classInitializer,
             BindingTrace trace,
             JetFile file
     ) {
-        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleDescriptor());
+        BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
+                                                                       trace, file, resolveSession.getModuleDescriptor());
         JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class);
-        LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject);
+        LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject);
         bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(),
                 classOrObjectDescriptor.getScopeForPropertyInitializerResolution());
 
@@ -314,17 +320,19 @@ public class ResolveElementCache {
     private static BodyResolver createBodyResolver(BindingTrace trace, JetFile file, BodyResolveContextForLazy bodyResolveContext,
             ModuleDescriptor module) {
         TopDownAnalysisParameters parameters = new TopDownAnalysisParameters(
+                bodyResolveContext.getStorageManager(),
                 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,
             BindingTrace trace,
             JetFile file,
             ModuleDescriptor module
     ) {
-        return createBodyResolver(trace, file, EMPTY_CONTEXT, module);
+        return createBodyResolver(trace, file, new BodyResolveContextForLazy(storageManager, Functions.<JetScope>constant(null)), module);
     }
 
     private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) {
@@ -413,12 +421,19 @@ public class ResolveElementCache {
 
     private static class BodyResolveContextForLazy implements BodiesResolveContext {
 
+        private final StorageManager storageManager;
         private final Function<? super JetDeclaration, JetScope> declaringScopes;
 
-        private BodyResolveContextForLazy(@NotNull Function<? super JetDeclaration, JetScope> declaringScopes) {
+        private BodyResolveContextForLazy(StorageManager storageManager, @NotNull Function<? super JetDeclaration, JetScope> declaringScopes) {
+            this.storageManager = storageManager;
             this.declaringScopes = declaringScopes;
         }
 
+        @Override
+        public StorageManager getStorageManager() {
+            return storageManager;
+        }
+
         @Override
         public Collection<JetFile> getFiles() {
             return Collections.emptySet();

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

@@ -44,6 +44,7 @@ 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.ExceptionUtils;
 
 import java.io.File;
@@ -84,6 +85,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
             @Override
             public void run() {
                 TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
+                        new LockBasedStorageManager(),
                         Predicates.<PsiFile>alwaysFalse(), true, false, Collections.<AnalyzerScriptParameter>emptyList());
                 ModuleDescriptorImpl module = new ModuleDescriptorImpl(
                         Name.special("<fake_module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);

js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
@@ -61,7 +61,7 @@ public class InjectorForTopDownAnalyzerForJs {
     private final ControlFlowAnalyzer controlFlowAnalyzer;
     private final DeclarationsChecker declarationsChecker;
     private final DescriptorResolver descriptorResolver;
-    private final LockBasedStorageManager storageManager;
+    private final StorageManager storageManager;
     private final CallResolverExtensionProvider callResolverExtensionProvider;
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
@@ -101,7 +101,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.descriptorResolver = new DescriptorResolver();
-        this.storageManager = new LockBasedStorageManager();
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.callResolverExtensionProvider = new CallResolverExtensionProvider();
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
@@ -114,7 +114,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingServices = new ExpressionTypingServices();
+        this.expressionTypingServices = new ExpressionTypingServices(storageManager, platformToKotlinClassMap);
         this.callExpressionResolver = new CallExpressionResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -162,6 +162,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.descriptorResolver.setAnnotationResolver(annotationResolver);
         this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        this.descriptorResolver.setStorageManager(storageManager);
         this.descriptorResolver.setTypeResolver(typeResolver);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
@@ -187,7 +188,6 @@ public class InjectorForTopDownAnalyzerForJs {
         expressionTypingServices.setCallResolver(callResolver);
         expressionTypingServices.setDescriptorResolver(descriptorResolver);
         expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
-        expressionTypingServices.setPlatformToKotlinClassMap(platformToKotlinClassMap);
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 

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

@@ -34,10 +34,10 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
-import org.jetbrains.jet.storage.LockBasedLazyResolveStorageManager;
 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.LockBasedLazyResolveStorageManager;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.k2js.config.Config;
 
@@ -91,7 +91,7 @@ public final class AnalyzerFacadeForJS {
         Predicate<PsiFile> completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely);
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                completely, false, false, Collections.<AnalyzerScriptParameter>emptyList());
+                new LockBasedStorageManager(), completely, false, false, Collections.<AnalyzerScriptParameter>emptyList());
 
         ModuleDescriptor libraryModule = config.getLibraryModule();
         if (libraryModule != null) {