Simplify injectors for frontend.java

- delete InjectorForJavaSemanticServices, replace its usages with
  InjectorForJavaDescriptorResolver
- delete unneeded fields and parameters of InjectorForJavaDescriptorResolver

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

@@ -18,19 +18,17 @@ package org.jetbrains.jet.di;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
@@ -46,19 +44,17 @@ public class InjectorForJavaDescriptorResolver {
     
     private final Project project;
     private final BindingTrace bindingTrace;
-    private final ModuleDescriptor moduleDescriptor;
-    private final JavaBridgeConfiguration javaBridgeConfiguration;
-    private final JavaSemanticServices javaSemanticServices;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final PsiClassFinderImpl psiClassFinder;
-    private final PsiDeclarationProviderFactory psiDeclarationProviderFactory;
-    private final JavaTypeTransformer javaTypeTransformer;
     private final JavaClassResolver javaClassResolver;
     private final JavaAnnotationResolver javaAnnotationResolver;
     private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
     private final JavaFunctionResolver javaFunctionResolver;
     private final JavaValueParameterResolver javaValueParameterResolver;
+    private final JavaTypeTransformer javaTypeTransformer;
     private final JavaSignatureResolver javaSignatureResolver;
+    private final JavaSemanticServices javaSemanticServices;
+    private final PsiDeclarationProviderFactory psiDeclarationProviderFactory;
     private final DeserializedDescriptorResolver deserializedDescriptorResolver;
     private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
     private final JavaNamespaceResolver javaNamespaceResolver;
@@ -69,24 +65,21 @@ public class InjectorForJavaDescriptorResolver {
     
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
-        @NotNull BindingTrace bindingTrace,
+        @NotNull BindingTrace bindingTrace
-        @NotNull ModuleDescriptor moduleDescriptor
     ) {
         this.project = project;
         this.bindingTrace = bindingTrace;
-        this.moduleDescriptor = moduleDescriptor;
-        this.javaBridgeConfiguration = new JavaBridgeConfiguration();
-        this.javaSemanticServices = new JavaSemanticServices();
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.psiClassFinder = new PsiClassFinderImpl();
-        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
-        this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaClassResolver = new JavaClassResolver();
         this.javaAnnotationResolver = new JavaAnnotationResolver();
         this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
         this.javaFunctionResolver = new JavaFunctionResolver();
         this.javaValueParameterResolver = new JavaValueParameterResolver();
+        this.javaTypeTransformer = new JavaTypeTransformer();
         this.javaSignatureResolver = new JavaSignatureResolver();
+        this.javaSemanticServices = new JavaSemanticServices();
+        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
         this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
         this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
         this.javaNamespaceResolver = new JavaNamespaceResolver();
@@ -95,14 +88,6 @@ public class InjectorForJavaDescriptorResolver {
         this.javaInnerClassResolver = new JavaInnerClassResolver();
         this.javaPropertyResolver = new JavaPropertyResolver();
 
-        this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
-
-        this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
-        this.javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
-        this.javaSemanticServices.setTrace(bindingTrace);
-        this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
-
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
         this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
         this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
@@ -112,8 +97,6 @@ public class InjectorForJavaDescriptorResolver {
 
         this.psiClassFinder.setProject(project);
 
-        javaTypeTransformer.setResolver(javaDescriptorResolver);
-
         javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
         javaClassResolver.setFunctionResolver(javaFunctionResolver);
         javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
@@ -138,8 +121,15 @@ public class InjectorForJavaDescriptorResolver {
 
         javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
 
+        javaTypeTransformer.setResolver(javaDescriptorResolver);
+
         javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
+        javaSemanticServices.setPsiClassFinder(psiClassFinder);
+        javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
+        javaSemanticServices.setTypeTransformer(javaTypeTransformer);
+
         deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
         deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
         deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
@@ -174,26 +164,6 @@ public class InjectorForJavaDescriptorResolver {
     public void destroy() {
     }
     
-    public Project getProject() {
-        return this.project;
-    }
-    
-    public BindingTrace getBindingTrace() {
-        return this.bindingTrace;
-    }
-    
-    public ModuleDescriptor getModuleDescriptor() {
-        return this.moduleDescriptor;
-    }
-    
-    public JavaBridgeConfiguration getJavaBridgeConfiguration() {
-        return this.javaBridgeConfiguration;
-    }
-    
-    public JavaSemanticServices getJavaSemanticServices() {
-        return this.javaSemanticServices;
-    }
-    
     public JavaDescriptorResolver getJavaDescriptorResolver() {
         return this.javaDescriptorResolver;
     }

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

@@ -1,197 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.di;
-
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
-import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
-import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.lang.resolve.java.provider.PsiDeclarationProviderFactory;
-import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver;
-import org.jetbrains.jet.lang.resolve.java.resolver.JavaPropertyResolver;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.jet.generators.injectors.GenerateInjectors. DO NOT EDIT! */
-public class InjectorForJavaSemanticServices {
-    
-    private final JavaSemanticServices javaSemanticServices;
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    private final BindingTrace bindingTrace;
-    private final JavaBridgeConfiguration javaBridgeConfiguration;
-    private final PsiClassFinderImpl psiClassFinder;
-    private final ModuleDescriptorImpl moduleDescriptor;
-    private final Project project;
-    private final PsiDeclarationProviderFactory psiDeclarationProviderFactory;
-    private final JavaTypeTransformer javaTypeTransformer;
-    private final JavaClassResolver javaClassResolver;
-    private final JavaAnnotationResolver javaAnnotationResolver;
-    private final JavaCompileTimeConstResolver javaCompileTimeConstResolver;
-    private final JavaFunctionResolver javaFunctionResolver;
-    private final JavaValueParameterResolver javaValueParameterResolver;
-    private final JavaSignatureResolver javaSignatureResolver;
-    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
-    private final JavaNamespaceResolver javaNamespaceResolver;
-    private final JavaSupertypeResolver javaSupertypeResolver;
-    private final JavaConstructorResolver javaConstructorResolver;
-    private final JavaInnerClassResolver javaInnerClassResolver;
-    private final JavaPropertyResolver javaPropertyResolver;
-    
-    public InjectorForJavaSemanticServices(
-        @NotNull Project project
-    ) {
-        this.javaSemanticServices = new JavaSemanticServices();
-        this.javaDescriptorResolver = new JavaDescriptorResolver();
-        this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext();
-        this.javaBridgeConfiguration = new JavaBridgeConfiguration();
-        this.psiClassFinder = new PsiClassFinderImpl();
-        this.moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl(org.jetbrains.jet.lang.resolve.name.Name.special("<dummy>"), org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration.ALL_JAVA_IMPORTS, org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap.getInstance());
-        this.project = project;
-        this.psiDeclarationProviderFactory = new PsiDeclarationProviderFactory(getPsiClassFinder());
-        this.javaTypeTransformer = new JavaTypeTransformer();
-        this.javaClassResolver = new JavaClassResolver();
-        this.javaAnnotationResolver = new JavaAnnotationResolver();
-        this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver();
-        this.javaFunctionResolver = new JavaFunctionResolver();
-        this.javaValueParameterResolver = new JavaValueParameterResolver();
-        this.javaSignatureResolver = new JavaSignatureResolver();
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
-        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer();
-        this.javaNamespaceResolver = new JavaNamespaceResolver();
-        this.javaSupertypeResolver = new JavaSupertypeResolver();
-        this.javaConstructorResolver = new JavaConstructorResolver();
-        this.javaInnerClassResolver = new JavaInnerClassResolver();
-        this.javaPropertyResolver = new JavaPropertyResolver();
-
-        this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
-        this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
-        this.javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
-        this.javaSemanticServices.setTrace(bindingTrace);
-        this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
-
-        this.javaDescriptorResolver.setClassResolver(javaClassResolver);
-        this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
-        this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
-        this.javaDescriptorResolver.setInnerClassResolver(javaInnerClassResolver);
-        this.javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver);
-        this.javaDescriptorResolver.setPropertiesResolver(javaPropertyResolver);
-
-        javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
-
-        this.psiClassFinder.setProject(project);
-
-        moduleDescriptor.setModuleConfiguration(javaBridgeConfiguration);
-
-        javaTypeTransformer.setResolver(javaDescriptorResolver);
-
-        javaClassResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaClassResolver.setFunctionResolver(javaFunctionResolver);
-        javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver);
-        javaClassResolver.setNamespaceResolver(javaNamespaceResolver);
-        javaClassResolver.setPsiClassFinder(psiClassFinder);
-        javaClassResolver.setSemanticServices(javaSemanticServices);
-        javaClassResolver.setSignatureResolver(javaSignatureResolver);
-        javaClassResolver.setSupertypesResolver(javaSupertypeResolver);
-        javaClassResolver.setTrace(bindingTrace);
-
-        javaAnnotationResolver.setClassResolver(javaClassResolver);
-        javaAnnotationResolver.setCompileTimeConstResolver(javaCompileTimeConstResolver);
-
-        javaCompileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaCompileTimeConstResolver.setClassResolver(javaClassResolver);
-
-        javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaFunctionResolver.setParameterResolver(javaValueParameterResolver);
-        javaFunctionResolver.setSignatureResolver(javaSignatureResolver);
-        javaFunctionResolver.setTrace(bindingTrace);
-        javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaValueParameterResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaSignatureResolver.setJavaSemanticServices(javaSemanticServices);
-
-        deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
-        deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver);
-        deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver);
-
-        annotationDescriptorDeserializer.setJavaClassResolver(javaClassResolver);
-        annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder);
-
-        javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver);
-        javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices);
-        javaNamespaceResolver.setPsiClassFinder(psiClassFinder);
-        javaNamespaceResolver.setTrace(bindingTrace);
-
-        javaSupertypeResolver.setClassResolver(javaClassResolver);
-        javaSupertypeResolver.setTrace(bindingTrace);
-        javaSupertypeResolver.setTypeTransformer(javaTypeTransformer);
-
-        javaConstructorResolver.setTrace(bindingTrace);
-        javaConstructorResolver.setTypeTransformer(javaTypeTransformer);
-        javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver);
-
-        javaInnerClassResolver.setClassResolver(javaClassResolver);
-
-        javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
-        javaPropertyResolver.setSemanticServices(javaSemanticServices);
-        javaPropertyResolver.setTrace(bindingTrace);
-
-        psiClassFinder.initialize();
-
-    }
-    
-    @PreDestroy
-    public void destroy() {
-    }
-    
-    public JavaSemanticServices getJavaSemanticServices() {
-        return this.javaSemanticServices;
-    }
-    
-    public JavaDescriptorResolver getJavaDescriptorResolver() {
-        return this.javaDescriptorResolver;
-    }
-    
-    public BindingTrace getBindingTrace() {
-        return this.bindingTrace;
-    }
-    
-    public PsiClassFinderImpl getPsiClassFinder() {
-        return this.psiClassFinder;
-    }
-    
-    public Project getProject() {
-        return this.project;
-    }
-    
-}

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

@@ -287,7 +287,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
         javaSemanticServices.setPsiClassFinder(psiClassFinder);
         javaSemanticServices.setPsiDeclarationProviderFactory(psiDeclarationProviderFactory);
-        javaSemanticServices.setTrace(bindingTrace);
         javaSemanticServices.setTypeTransformer(javaTypeTransformer);
 
         javaTypeTransformer.setResolver(javaDescriptorResolver);

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

@@ -78,10 +78,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
     @NotNull
     @Override
     public ResolveSession getLazyResolveSession(@NotNull Project fileProject, @NotNull Collection<JetFile> files) {
-        ModuleDescriptorImpl javaModule = createJavaModule("<java module>");
-
         BindingTraceContext javaResolverTrace = new BindingTraceContext();
-        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(fileProject, javaResolverTrace, javaModule);
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(fileProject, javaResolverTrace);
 
         final PsiClassFinder psiClassFinder = injector.getPsiClassFinder();
 
@@ -115,7 +113,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
                 }
             }
         };
-        javaModule.setModuleConfiguration(moduleConfiguration);
 
         ModuleDescriptorImpl lazyModule = createJavaModule("<lazy module>");
         lazyModule.setModuleConfiguration(moduleConfiguration);

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

@@ -35,8 +35,6 @@ public class JavaSemanticServices {
     @NotNull
     private PsiClassFinder psiClassFinder;
     @NotNull
-    private BindingTrace trace;
-    @NotNull
     private PsiDeclarationProviderFactory psiDeclarationProviderFactory;
 
     @Inject
@@ -55,8 +53,8 @@ public class JavaSemanticServices {
     }
 
     @Inject
-    public void setTrace(@NotNull BindingTrace trace) {
+    public void setPsiDeclarationProviderFactory(@NotNull PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
-        this.trace = trace;
+        this.psiDeclarationProviderFactory = psiDeclarationProviderFactory;
     }
 
     @NotNull
@@ -64,21 +62,11 @@ public class JavaSemanticServices {
         return typeTransformer;
     }
 
-    @Inject
-    public void setPsiDeclarationProviderFactory(PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
-        this.psiDeclarationProviderFactory = psiDeclarationProviderFactory;
-    }
-
     @NotNull
     public JavaDescriptorResolver getDescriptorResolver() {
         return descriptorResolver;
     }
 
-    @Nullable
-    public ClassDescriptor getKotlinClassDescriptor(@NotNull FqName qualifiedName) {
-        return trace.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName);
-    }
-
     @NotNull
     public PsiClassFinder getPsiClassFinder() {
         return psiClassFinder;
@@ -88,9 +76,4 @@ public class JavaSemanticServices {
     public PsiDeclarationProviderFactory getPsiDeclarationProviderFactory() {
         return psiDeclarationProviderFactory;
     }
-
-    @Nullable
-    public NamespaceDescriptor getKotlinNamespaceDescriptor(@NotNull FqName qualifiedName) {
-        return trace.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, qualifiedName);
-    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -166,7 +166,7 @@ public final class JavaClassResolver {
         }
 
         // First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
-        ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
+        ClassDescriptor kotlinClassDescriptor = trace.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName);
         if (kotlinClassDescriptor != null) {
             return searchRule.processFoundInKotlin(kotlinClassDescriptor);
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -92,7 +92,7 @@ public final class JavaNamespaceResolver {
     @Nullable
     public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         // First, let's check that there is no Kotlin package:
-        NamespaceDescriptor kotlinNamespaceDescriptor = javaSemanticServices.getKotlinNamespaceDescriptor(qualifiedName);
+        NamespaceDescriptor kotlinNamespaceDescriptor = trace.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, qualifiedName);
         if (kotlinNamespaceDescriptor != null) {
             return searchRule.processFoundInKotlin(kotlinNamespaceDescriptor);
         }

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -57,8 +57,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
-import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -625,8 +623,7 @@ public class JetTestUtils {
 
     @NotNull
     public static NamespaceDescriptorImpl createTestNamespace(@NotNull Name testPackageName) {
-        ModuleDescriptorImpl module = new ModuleDescriptorImpl(Name.special("<test module>"), JavaBridgeConfiguration.ALL_JAVA_IMPORTS,
+        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<test module>");
-                                                               JavaToKotlinClassMap.getInstance());
         NamespaceDescriptorImpl rootNamespace =
                 new NamespaceDescriptorImpl(module, Collections.<AnnotationDescriptor>emptyList(), JetPsiUtil.ROOT_NAMESPACE_NAME);
         module.setRootNamespace(rootNamespace);

compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java

@@ -63,8 +63,8 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith
         NamespaceDescriptor testNamespace = moduleDescriptor.getNamespace(FqName.topLevel(TEST_PACKAGE_NAME));
         assert testNamespace != null;
 
-        JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaDescriptorResolver(
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
-                getProject(), new BindingTraceContext(), moduleDescriptor).getJavaDescriptorResolver();
+        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
         NamespaceDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testNamespace);
 

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

@@ -142,15 +142,12 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("compiler/tests")); // for @ExpectLoadError annotation
         JetCoreEnvironment environment = new JetCoreEnvironment(getTestRootDisposable(), configuration);
 
-        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<test module>");
-
         // we need the same binding trace for resolve from Java and Kotlin
         BindingTrace trace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace();
 
-        InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(),
+        InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(), trace);
-                                                                                                  trace,
-                                                                                                  moduleDescriptor);
 
+        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<test module>");
         InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
                 environment.getProject(),
                 new TopDownAnalysisParameters(

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

@@ -36,10 +36,12 @@ import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.config.CompilerConfiguration;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -91,9 +93,10 @@ public class JdkAnnotationsValidityTest extends UsefulTestCase {
             try {
                 JetCoreEnvironment commonEnvironment = createEnvironment(parentDisposable);
 
-                InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(commonEnvironment.getProject());
+                BindingTrace trace = new BindingTraceContext();
+                InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(commonEnvironment.getProject(), trace);
 
-                BindingContext bindingContext = injector.getBindingTrace().getBindingContext();
+                BindingContext bindingContext = trace.getBindingContext();
                 JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
                 AlternativeSignatureErrorFindingVisitor visitor = new AlternativeSignatureErrorFindingVisitor(bindingContext, errors);

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

@@ -28,17 +28,16 @@ import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationUtils;
-import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -97,13 +96,13 @@ public final class LoadDescriptorUtil {
                 new File("compiler/tests") // for @ExpectLoadError annotation
         );
         JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, configuration);
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject());
+        BindingTraceContext trace = new BindingTraceContext();
-        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(jetCoreEnvironment.getProject(), trace);
         NamespaceDescriptor namespaceDescriptor =
-                javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
+                injector.getJavaDescriptorResolver().resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
         assert namespaceDescriptor != null;
 
-        return Pair.create(namespaceDescriptor, injector.getBindingTrace().getBindingContext());
+        return Pair.create(namespaceDescriptor, trace.getBindingContext());
     }
 
     @NotNull

compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java

@@ -26,12 +26,17 @@ import org.apache.commons.httpclient.methods.GetMethod;
 import org.apache.commons.httpclient.params.HttpMethodParams;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.*;
+import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.TestJdkKind;
+import org.jetbrains.jet.TimeUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.config.CompilerConfiguration;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.utils.PathUtil;
 
@@ -151,8 +156,9 @@ public class ResolveDescriptorsFromExternalLibraries {
             }
         }
 
-
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject());
+                jetCoreEnvironment.getProject(), new BindingTraceContext());
+        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
         boolean hasErrors;
         try {
@@ -184,7 +190,7 @@ public class ResolveDescriptorsFromExternalLibraries {
                 String className = entryName.substring(0, entryName.length() - ".class".length()).replace("/", ".");
 
                 try {
-                    ClassDescriptor clazz = injector.getJavaDescriptorResolver().resolveClass(new FqName(className), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
+                    ClassDescriptor clazz = javaDescriptorResolver.resolveClass(new FqName(className), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
                     if (clazz == null) {
                         throw new IllegalStateException("class not found by name " + className + " in " + libDescription);
                     }

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

@@ -90,16 +90,12 @@ public class LazyResolveTestUtil {
     public static KotlinCodeAnalyzer resolveLazilyWithSession(List<JetFile> files, JetCoreEnvironment environment, final boolean addBuiltIns) {
         JetTestUtils.newTrace(environment);
 
-        ModuleDescriptorImpl javaModule = AnalyzerFacadeForJVM.createJavaModule("<java module>");
-
         Project project = environment.getProject();
         BindingTrace sharedTrace = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()).getTrace();
-        InjectorForJavaDescriptorResolver injector =
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, sharedTrace);
-                new InjectorForJavaDescriptorResolver(project, sharedTrace, javaModule);
         final PsiClassFinder psiClassFinder = injector.getPsiClassFinder();
         final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
-
         LockBasedStorageManager storageManager = new LockBasedStorageManager();
         FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(storageManager, files, new Predicate<FqName>() {
             @Override
@@ -127,7 +123,6 @@ public class LazyResolveTestUtil {
                 }
             }
         };
-        javaModule.setModuleConfiguration(moduleConfiguration);
 
         ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
         lazyModule.setModuleConfiguration(moduleConfiguration);

compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java

@@ -21,7 +21,7 @@ import com.intellij.psi.*;
 import junit.framework.Assert;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -114,7 +114,7 @@ public class JetExpectedResolveDataUtil {
 
     @NotNull
     private static PsiClass findClass(String qualifiedName, Project project) {
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project);
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, new BindingTraceContext());
         PsiClass psiClass = injector.getPsiClassFinder().findPsiClass(new FqName(qualifiedName), PsiClassFinder.RuntimeClassesHandleMode.REPORT_ERROR);
         Assert.assertNotNull("Class wasn't found: " + qualifiedName, psiClass);
         return psiClass;

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -25,7 +25,7 @@ import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
-import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
@@ -57,7 +57,6 @@ import java.util.*;
 public class JetTypeCheckerTest extends JetLiteFixture {
 
     private KotlinBuiltIns builtIns;
-    private DescriptorResolver descriptorResolver;
     private JetScope scopeWithImports;
     private TypeResolver typeResolver;
     private ExpressionTypingServices expressionTypingServices;
@@ -79,7 +78,6 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         builtIns = KotlinBuiltIns.getInstance();
 
         InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
-        descriptorResolver = injector.getDescriptorResolver();
         typeResolver = injector.getTypeResolver();
         expressionTypingServices = injector.getExpressionTypingServices();
 
@@ -92,7 +90,6 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
         expressionTypingServices = null;
         typeResolver = null;
-        descriptorResolver = null;
 
         builtIns = null;
 
@@ -586,7 +583,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     private WritableScopeImpl addImports(JetScope scope) {
         WritableScopeImpl writableScope = new WritableScopeImpl(
                 scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(getProject());
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
         writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT,
                 DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope());

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

@@ -24,17 +24,20 @@ import org.jetbrains.jet.codegen.ScriptCodegen;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
-import org.jetbrains.jet.di.*;
+import org.jetbrains.jet.di.DependencyInjectorGenerator;
+import org.jetbrains.jet.di.GivenExpression;
+import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.NeedSyntheticCallResolverExtension;
-import org.jetbrains.jet.lang.resolve.java.*;
+import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
-import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -55,7 +58,6 @@ public class GenerateInjectors {
         generateInjectorForTopDownAnalyzerForJs();
         generateMacroInjector();
         generateTestInjector();
-        generateInjectorForJavaSemanticServices();
         generateInjectorForJvmCodegen();
         generateInjectorForLazyResolve();
         generateInjectorForBodyResolve();
@@ -109,13 +111,10 @@ public class GenerateInjectors {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
 
         // Parameters
-        generator.addPublicParameter(Project.class);
+        generator.addParameter(Project.class);
-        generator.addPublicParameter(BindingTrace.class);
+        generator.addParameter(BindingTrace.class);
-        generator.addPublicParameter(ModuleDescriptor.class);
 
         // Fields
-        generator.addPublicField(JavaBridgeConfiguration.class);
-        generator.addPublicField(JavaSemanticServices.class);
         generator.addPublicField(JavaDescriptorResolver.class);
         generator.addPublicField(PsiClassFinderImpl.class);
 
@@ -172,29 +171,6 @@ public class GenerateInjectors {
         generator.generate("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests", GenerateInjectors.class);
     }
 
-    private static void generateInjectorForJavaSemanticServices() throws IOException {
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
-
-        // Fields
-        generator.addPublicField(JavaSemanticServices.class);
-        generator.addPublicField(JavaDescriptorResolver.class);
-        generator.addField(true, BindingTrace.class, null,
-                           new GivenExpression("new org.jetbrains.jet.lang.resolve.BindingTraceContext()"));
-        generator.addField(JavaBridgeConfiguration.class);
-        generator.addPublicField(PsiClassFinderImpl.class);
-        generator.addField(false, ModuleDescriptorImpl.class, null,
-                           new GivenExpression("new " + ModuleDescriptorImpl.class.getCanonicalName() + "(" +
-                                               Name.class.getCanonicalName() + ".special(\"<dummy>\"), " +
-                                               JavaBridgeConfiguration.class.getCanonicalName() + ".ALL_JAVA_IMPORTS, " +
-                                               JavaToKotlinClassMap.class.getCanonicalName() + ".getInstance())"));
-
-        // Parameters
-        generator.addPublicParameter(Project.class);
-
-        generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForJavaSemanticServices",
-                           GenerateInjectors.class);
-    }
-
     private static void generateInjectorForJvmCodegen() throws IOException {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator();
 

idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureAnnotationIntention.java

@@ -33,9 +33,11 @@ import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.messages.MessageBusConnection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -159,7 +161,8 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl
 
     @NotNull
     private static String getDefaultSignature(@NotNull Project project, @NotNull PsiMember psiMember) {
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project);
+        BindingTraceContext trace = new BindingTraceContext();
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, trace);
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
 
         PsiClass containingClass = psiMember.getContainingClass();
@@ -169,11 +172,11 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl
         FqName classFqName = new FqName(qualifiedName);
 
         if (psiMember instanceof PsiMethod) {
-            return getDefaultSignature((PsiMethod) psiMember, classFqName, javaDescriptorResolver, injector.getBindingTrace().getBindingContext());
+            return getDefaultSignature((PsiMethod) psiMember, classFqName, javaDescriptorResolver, trace.getBindingContext());
         }
 
         if (psiMember instanceof PsiField) {
-            return getDefaultSignature((PsiField) psiMember, classFqName, javaDescriptorResolver, injector.getBindingTrace().getBindingContext());
+            return getDefaultSignature((PsiField) psiMember, classFqName, javaDescriptorResolver, trace.getBindingContext());
         }
 
         throw new IllegalStateException("PsiMethod or PsiField are expected");

idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureInJavaMarkerProvider.java

@@ -34,11 +34,12 @@ import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
-import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope;
@@ -83,10 +84,10 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
             return;
         }
 
-        InjectorForJavaDescriptorResolver injector = createInjector(project);
+        BindingTrace trace = createDelegatingTrace(project);
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, trace);
 
         JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
-        BindingTrace trace = injector.getBindingTrace();
 
         for (PsiElement element : elements) {
             if (!(element instanceof PsiMember)) {
@@ -111,15 +112,11 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         }
     }
 
-    static InjectorForJavaDescriptorResolver createInjector(Project project) {
+    @NotNull
+    static BindingTrace createDelegatingTrace(@NotNull Project project) {
         KotlinDeclarationsCache declarationsCache = KotlinCacheManager.getInstance(project).getDeclarationsFromProject(TargetPlatform.JVM);
         BindingContext bindingContext = declarationsCache.getBindingContext();
-        DelegatingBindingTrace delegatingTrace = new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
+        return new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
-
-        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<fake>");
-        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, delegatingTrace, moduleDescriptor);
-        moduleDescriptor.setModuleConfiguration(injector.getJavaBridgeConfiguration());
-        return injector;
     }
 
     @Nullable

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.plugin.libraries;
 
-import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
@@ -25,12 +24,13 @@ import com.intellij.psi.impl.compiled.ClsElementImpl;
 import com.intellij.psi.impl.compiled.ClsFileImpl;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.MemberComparator;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
@@ -57,10 +57,11 @@ public class DecompiledDataFactory {
 
     private DecompiledDataFactory(ClsFileImpl clsFile) {
         this.clsFile = clsFile;
-        Project project = this.clsFile.getProject();
+
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project);
+        BindingTraceContext trace = new BindingTraceContext();
-        bindingContext = injector.getBindingTrace().getBindingContext();
+        this.bindingContext = trace.getBindingContext();
-        javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(clsFile.getProject(), trace);
+        this.javaDescriptorResolver = injector.getJavaDescriptorResolver();
     }
 
     @NotNull

idea/tests/org/jetbrains/jet/plugin/ktSignature/SignatureMarkerProviderTest.java

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.plugin.JetLightProjectDescriptor;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
-import org.jetbrains.jet.plugin.ktSignature.KotlinSignatureInJavaMarkerProvider;
 import org.jetbrains.jet.plugin.project.TargetPlatform;
 
 public class SignatureMarkerProviderTest extends LightCodeInsightFixtureTestCase {
@@ -52,7 +51,8 @@ public class SignatureMarkerProviderTest extends LightCodeInsightFixtureTestCase
         BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject(TargetPlatform.JVM).getBindingContext();
         ClassDescriptor preResolvedClass = context.get(BindingContext.CLASS, psiClass);
 
-        InjectorForJavaDescriptorResolver injector = KotlinSignatureInJavaMarkerProvider.createInjector(project);
+        InjectorForJavaDescriptorResolver injector =
+                new InjectorForJavaDescriptorResolver(project, KotlinSignatureInJavaMarkerProvider.createDelegatingTrace(project));
         ClassDescriptor reResolvedClass = injector.getJavaDescriptorResolver().resolveClass(new FqName("java.lang.Thread"));
 
         assertSame(preResolvedClass, reResolvedClass);