Generate Injectors: add ability to specify that a field is a context

Context field's properties can injected into other components
Use it in GenerateInjectors.kt

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.di;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
@@ -27,7 +28,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
-import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
@@ -43,6 +43,7 @@ public class InjectorForJavaDescriptorResolver {
     private final Project project;
     private final BindingTrace bindingTrace;
     private final GlobalContextImpl globalContext;
+    private final LockBasedStorageManager lockBasedStorageManager;
     private final ModuleDescriptorImpl module;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JavaClassFinderImpl javaClassFinder;
@@ -51,7 +52,6 @@ public class InjectorForJavaDescriptorResolver {
     private final TraceBasedErrorReporter traceBasedErrorReporter;
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
-    private final StorageManager storageManager;
     private final VirtualFileFinder virtualFileFinder;
     private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
     private final GlobalJavaResolverContext globalJavaResolverContext;
@@ -65,8 +65,8 @@ public class InjectorForJavaDescriptorResolver {
         this.project = project;
         this.bindingTrace = bindingTrace;
         this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
+        this.lockBasedStorageManager = globalContext.getStorageManager();
         this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule("<fake-jdr-module>");
-        this.storageManager = globalContext.getStorageManager();
         this.javaClassFinder = new JavaClassFinderImpl();
         this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
@@ -75,10 +75,10 @@ public class InjectorForJavaDescriptorResolver {
         this.traceBasedErrorReporter = new TraceBasedErrorReporter();
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache);
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, getJavaClassFinder(), virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, traceBasedJavaResolverCache);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(storageManager);
+        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(lockBasedStorageManager);
 
         this.javaClassFinder.setProject(project);
 
@@ -96,7 +96,7 @@ public class InjectorForJavaDescriptorResolver {
         deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
         deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
         deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
-        deserializedDescriptorResolver.setStorageManager(storageManager);
+        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
 
         annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
         annotationDescriptorDeserializer.setJavaDescriptorResolver(javaDescriptorResolver);

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

@@ -18,11 +18,11 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext;
-import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
@@ -69,11 +69,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
+    private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
     private final TopDownAnalyzer topDownAnalyzer;
     private final TopDownAnalysisContext topDownAnalysisContext;
-    private final StorageManager storageManager;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final JavaToKotlinClassMap javaToKotlinClassMap;
@@ -120,11 +120,11 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     ) {
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
-        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
         this.javaClassFinder = new JavaClassFinderImpl();
         this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);

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

@@ -18,12 +18,12 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
-import org.jetbrains.jet.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -49,12 +49,12 @@ public class InjectorForBodyResolve {
     
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
+    private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
     private final BodiesResolveContext bodiesResolveContext;
     private final ModuleDescriptor moduleDescriptor;
-    private final BodyResolver bodyResolver;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final StorageManager storageManager;
+    private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -81,12 +81,12 @@ public class InjectorForBodyResolve {
     ) {
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.bindingTrace = bindingTrace;
         this.bodiesResolveContext = bodiesResolveContext;
         this.moduleDescriptor = moduleDescriptor;
-        this.bodyResolver = new BodyResolver();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
-        this.storageManager = topDownAnalysisParameters.getStorageManager();
+        this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();

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

@@ -18,12 +18,12 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.storage.StorageManager;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -46,12 +46,12 @@ public class InjectorForLazyResolve {
     
     private final Project project;
     private final GlobalContextImpl globalContext;
+    private final LockBasedStorageManager lockBasedStorageManager;
     private final ModuleDescriptorImpl moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final BindingTrace bindingTrace;
     private final ResolveSession resolveSession;
-    private final StorageManager storageManager;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -75,12 +75,12 @@ public class InjectorForLazyResolve {
     ) {
         this.project = project;
         this.globalContext = globalContext;
+        this.lockBasedStorageManager = globalContext.getStorageManager();
         this.moduleDescriptor = moduleDescriptor;
+        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
         this.bindingTrace = bindingTrace;
         this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
-        this.storageManager = resolveSession.getStorageManager();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -126,7 +126,7 @@ public class InjectorForLazyResolve {
         descriptorResolver.setAnnotationResolver(annotationResolver);
         descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
         descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
+        descriptorResolver.setStorageManager(lockBasedStorageManager);
         descriptorResolver.setTypeResolver(typeResolver);
 
         delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);

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

@@ -18,8 +18,8 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -41,8 +41,8 @@ public class InjectorForMacros {
     
     private final Project project;
     private final ModuleDescriptor moduleDescriptor;
-    private final ExpressionTypingServices expressionTypingServices;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final ExpressionTypingServices expressionTypingServices;
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final AnnotationResolver annotationResolver;
@@ -62,8 +62,8 @@ public class InjectorForMacros {
     ) {
         this.project = project;
         this.moduleDescriptor = moduleDescriptor;
-        this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
         this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap);
         this.storageManager = globalContext.getStorageManager();
         this.annotationResolver = new AnnotationResolver();

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

@@ -18,11 +18,11 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext;
-import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
@@ -58,11 +58,11 @@ public class InjectorForTopDownAnalyzerBasic {
     
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
+    private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
     private final TopDownAnalyzer topDownAnalyzer;
     private final TopDownAnalysisContext topDownAnalysisContext;
-    private final StorageManager storageManager;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
@@ -99,11 +99,11 @@ public class InjectorForTopDownAnalyzerBasic {
     ) {
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
-        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
         this.platformToKotlinClassMap = platformToKotlinClassMap;
         this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();

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

@@ -18,12 +18,12 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
-import org.jetbrains.jet.storage.StorageManager;
-import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.context.GlobalContext;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -41,12 +41,12 @@ public class InjectorForTests {
     
     private final Project project;
     private final ModuleDescriptor moduleDescriptor;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DescriptorResolver descriptorResolver;
     private final ExpressionTypingServices expressionTypingServices;
     private final TypeResolver typeResolver;
-    private final StorageManager storageManager;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final GlobalContext globalContext;
+    private final StorageManager storageManager;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -62,9 +62,9 @@ public class InjectorForTests {
     ) {
         this.project = project;
         this.moduleDescriptor = moduleDescriptor;
+        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.descriptorResolver = new DescriptorResolver();
         this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap);
         this.typeResolver = new TypeResolver();
         this.storageManager = globalContext.getStorageManager();

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

@@ -57,11 +57,9 @@ public val injectorGenerators: List<DependencyInjectorGenerator> by Delegates.la
 public class GenerateInjectors {
 
     private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() {
-        parameters(
+        parameter(javaClass<Project>())
-                javaClass<Project>(),
+        parameter(javaClass<TopDownAnalysisParameters>(), useAsContext = true)
-                javaClass<TopDownAnalysisParameters>(),
+        parameter(javaClass<BindingTrace>())
-                javaClass<BindingTrace>()
-        )
         publicParameter(javaClass<ModuleDescriptorImpl>())
 
         publicFields(
@@ -69,7 +67,6 @@ public class GenerateInjectors {
                 javaClass<TopDownAnalysisContext>()
         )
 
-        field(javaClass<StorageManager>(), init = GivenExpression("topDownAnalysisParameters.getStorageManager()"))
         field(javaClass<MutablePackageFragmentProvider>())
     }
 
@@ -117,7 +114,7 @@ public class GenerateInjectors {
                         javaClass<BindingTrace>()
                 )
 
-                publicField(javaClass<GlobalContextImpl>(),
+                publicField(javaClass<GlobalContextImpl>(), useAsContext = true,
                             init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
                 publicField(javaClass<ModuleDescriptorImpl>(), name = "module",
                             init = GivenExpression("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(\"<fake-jdr-module>\")"))
@@ -131,31 +128,25 @@ public class GenerateInjectors {
                         javaClass<PsiBasedMethodSignatureChecker>(),
                         javaClass<PsiBasedExternalAnnotationResolver>()
                 )
-                field(javaClass<StorageManager>(), init = GivenExpression("globalContext.getStorageManager()"))
                 field(javaClass<VirtualFileFinder>(),
                       init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
             }
 
     private val generatorForMacro =
             generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForMacros", javaClass<GenerateInjectors>()) {
-                parameters(
+                parameter(javaClass<Project>())
-                        javaClass<Project>(),
+                parameter(javaClass<ModuleDescriptor>(), useAsContext = true)
-                        javaClass<ModuleDescriptor>()
-                )
 
                 publicField(javaClass<ExpressionTypingServices>())
 
-                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
+                field(javaClass<GlobalContext>(), useAsContext = true,
-                field(javaClass<GlobalContext>(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
+                      init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
-                field(javaClass<StorageManager>(), init = GivenExpression("globalContext.getStorageManager()"))
             }
 
     private val generatorForTests =
             generator("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests", javaClass<GenerateInjectors>()) {
-                parameters(
+                parameter(javaClass<Project>())
-                        javaClass<Project>(),
+                parameter(javaClass<ModuleDescriptor>(), useAsContext = true)
-                        javaClass<ModuleDescriptor>()
-                )
 
                 publicFields(
                         javaClass<DescriptorResolver>(),
@@ -163,41 +154,30 @@ public class GenerateInjectors {
                         javaClass<TypeResolver>()
                 )
 
-                field(javaClass<StorageManager>(), init = GivenExpression("globalContext.getStorageManager()"))
+                field(javaClass<GlobalContext>(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"),
-                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
+                      useAsContext = true)
-                field(javaClass<GlobalContext>(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
             }
 
     private val generatorForBodyResolve =
             generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForBodyResolve", javaClass<GenerateInjectors>()) {
-                parameters(
+                parameter(javaClass<Project>())
-                        javaClass<Project>(),
+                parameter(javaClass<TopDownAnalysisParameters>(), useAsContext = true)
-                        javaClass<TopDownAnalysisParameters>(),
+                parameter(javaClass<BindingTrace>())
-                        javaClass<BindingTrace>(),
+                parameter(javaClass<BodiesResolveContext>())
-                        javaClass<BodiesResolveContext>(),
+                parameter(javaClass<ModuleDescriptor>(), useAsContext = true)
-                        javaClass<ModuleDescriptor>()
-                )
 
                 publicField(javaClass<BodyResolver>())
-
-                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
-                field(javaClass<StorageManager>(), init = GivenExpression("topDownAnalysisParameters.getStorageManager()"))
             }
 
     private val generatorForLazyResolve =
             generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve", javaClass<GenerateInjectors>()) {
-                parameters(
+                parameter(javaClass<Project>())
-                        javaClass<Project>(),
+                parameter(javaClass<GlobalContextImpl>(), useAsContext = true)
-                        javaClass<GlobalContextImpl>(),
+                parameter(javaClass<ModuleDescriptorImpl>(), useAsContext = true)
-                        javaClass<ModuleDescriptorImpl>(),
+                parameter(javaClass<DeclarationProviderFactory>())
-                        javaClass<DeclarationProviderFactory>(),
+                parameter(javaClass<BindingTrace>())
-                        javaClass<BindingTrace>()
-                )
 
                 publicField(javaClass<ResolveSession>())
-
-                field(javaClass<StorageManager>(), init = GivenExpression("resolveSession.getStorageManager()"))
-                field(javaClass<PlatformToKotlinClassMap>(), init = GivenExpression("moduleDescriptor.getPlatformToKotlinClassMap()"))
             }
 
     val generators = listOf(

injector-generator/src/org/jetbrains/jet/di/DependencyInjectorGenerator.java

@@ -19,7 +19,9 @@ package org.jetbrains.jet.di;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
+import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.utils.Printer;
@@ -154,8 +156,8 @@ public class DependencyInjectorGenerator {
         implementsList.add(superInterface);
     }
 
-    public void addParameter(boolean reexport, @NotNull DiType type, @Nullable String name, boolean required) {
+    public void addParameter(boolean reexport, @NotNull DiType type, @Nullable String name, boolean required, boolean useAsContext) {
-        Field field = addField(reexport, type, name, null);
+        Field field = addField(reexport, type, name, null, useAsContext);
         Parameter parameter = new Parameter(type, name, field, required);
         parameters.add(parameter);
         field.setInitialization(new ParameterExpression(parameter));
@@ -163,11 +165,20 @@ public class DependencyInjectorGenerator {
         dependencies.addSatisfiedField(field);
     }
 
-    public Field addField(boolean isPublic, DiType type, @Nullable String name, @Nullable Expression init) {
+    public Field addField(boolean isPublic, DiType type, @Nullable String name, @Nullable Expression init, boolean useAsContext) {
         Field field = Field.create(isPublic, type, name == null ? var(type) : name, init);
+        addField(field);
+        if (useAsContext) {
+            for (Field accessibleViaGetter : field.getFieldsAccessibleViaGetters()) {
+                addField(accessibleViaGetter);
+            }
+        }
+        return field;
+    }
+
+    private void addField(@NotNull Field field) {
         fields.add(field);
         dependencies.addField(field);
-        return field;
     }
 
     public void addFactoryMethod(@NotNull Class<?> returnType, Class<?>... parameterTypes) {
@@ -203,11 +214,21 @@ public class DependencyInjectorGenerator {
     }
 
     private void generateFields(Printer out) {
-        for (Field field : fields) {
+        for (Field field : getUsedFields()) {
             out.println("private final " + type(InjectorGeneratorUtil.getEffectiveFieldType(field)) + " " + field.getName() + ";");
         }
     }
 
+    @NotNull
+    private List<Field> getUsedFields() {
+        return ContainerUtil.filter(fields, new Condition<Field>() {
+            @Override
+            public boolean value(Field field) {
+                return dependencies.getUsedFields().contains(field) || field.isPublic();
+            }
+        });
+    }
+
     private void generateConstructor(String injectorClassName, Printer p) {
         // Constructor parameters
         if (parameters.isEmpty()) {
@@ -220,7 +241,7 @@ public class DependencyInjectorGenerator {
 
         p.pushIndent();
 
-        InjectionLogicGenerator.generateForFields(p, fields);
+        InjectionLogicGenerator.generateForFields(p, getUsedFields());
 
         p.popIndent();
         p.println("}");

injector-generator/src/org/jetbrains/jet/di/Field.java

@@ -21,7 +21,13 @@ import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.lang.reflect.Method;
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static org.jetbrains.jet.di.InjectorGeneratorUtil.var;
 
 class Field {
 
@@ -113,4 +119,36 @@ class Field {
         result = 31 * result + name.hashCode();
         return result;
     }
+
+    @NotNull
+    public List<Field> getFieldsAccessibleViaGetters() {
+        Class<?> clazz = type.getClazz();
+        List<Field> result = Lists.newArrayList();
+        for (Method method : allGetters(clazz)) {
+            DiType type = DiType.fromReflectionType(method.getGenericReturnType());
+            result.add(create(false, type, var(type), new GivenExpression(this.getName() + "." + method.getName() + "()")));
+        }
+        return result;
+    }
+
+    @NotNull
+    private static Collection<Method> allGetters(@NotNull Class clazz) {
+        Map<String, Method> getters = new TreeMap<String, Method>();
+        for (Method method : clazz.getMethods()) {
+            if (method.getDeclaringClass() == Object.class) {
+                continue;
+            }
+            if (isGetter(method)) {
+                if (!getters.containsKey(method.getName())) {
+                    getters.put(method.getName(), method);
+                }
+            }
+        }
+        return getters.values();
+    }
+
+    private static boolean isGetter(@NotNull Method method) {
+        String name = method.getName();
+        return name.startsWith("get") && name.length() > 3 && method.getParameterTypes().length == 0;
+    }
 }

injector-generator/src/org/jetbrains/jet/di/InjectorGeneratorFacade.kt

@@ -32,17 +32,19 @@ public fun generator(
 public fun DependencyInjectorGenerator.field(
         fieldType: Class<*>,
         name: String = defaultName(fieldType),
-        init: Expression? = null
+        init: Expression? = null,
+        useAsContext: Boolean = false
 ) {
-    addField(false, DiType(fieldType), name, init)
+    addField(false, DiType(fieldType), name, init, useAsContext)
 }
 
 public fun DependencyInjectorGenerator.publicField(
         fieldType: Class<*>,
         name: String = defaultName(fieldType),
-        init: Expression? = null
+        init: Expression? = null,
+        useAsContext: Boolean = false
 ) {
-    addField(true, DiType(fieldType), name, init)
+    addField(true, DiType(fieldType), name, init, useAsContext)
 }
 
 public fun DependencyInjectorGenerator.fields(vararg types: Class<*>): Unit = types.forEach { field(it) }
@@ -50,16 +52,18 @@ public fun DependencyInjectorGenerator.publicFields(vararg types: Class<*>): Uni
 
 public fun DependencyInjectorGenerator.parameter(
         parameterType: Class<*>,
-        name: String = defaultName(parameterType)
+        name: String = defaultName(parameterType),
+        useAsContext: Boolean = false
 ) {
-    addParameter(false, DiType(parameterType), name, true)
+    addParameter(false, DiType(parameterType), name, true, useAsContext)
 }
 
 public fun DependencyInjectorGenerator.publicParameter(
         parameterType: Class<*>,
-        name: String = defaultName(parameterType)
+        name: String = defaultName(parameterType),
+        useAsContext: Boolean = false
 ) {
-    addParameter(true, DiType(parameterType), name, true)
+    addParameter(true, DiType(parameterType), name, true, useAsContext)
 }
 
 public fun DependencyInjectorGenerator.parameters(vararg types: Class<*>): Unit = types.forEach { parameter(it) }

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

@@ -18,11 +18,11 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext;
-import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
@@ -58,11 +58,11 @@ public class InjectorForTopDownAnalyzerForJs {
     
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
+    private final StorageManager storageManager;
     private final BindingTrace bindingTrace;
     private final ModuleDescriptorImpl moduleDescriptor;
     private final TopDownAnalyzer topDownAnalyzer;
     private final TopDownAnalysisContext topDownAnalysisContext;
-    private final StorageManager storageManager;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
@@ -98,11 +98,11 @@ public class InjectorForTopDownAnalyzerForJs {
     ) {
         this.project = project;
         this.topDownAnalysisParameters = topDownAnalysisParameters;
+        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();
-        this.storageManager = topDownAnalysisParameters.getStorageManager();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
         this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl();
         this.platformToKotlinClassMap = org.jetbrains.jet.lang.PlatformToKotlinClassMap.EMPTY;