Simplify injectors for frontend.java

- delete InjectorForJavaSemanticServices, replace its usages with InjectorForJavaDescriptorResolver - delete unneeded fields and parameters of InjectorForJavaDescriptorResolver
2013-07-24 18:35:05 +04:00
parent 3bd9d9ee32
commit 2d7a5ebf36
21 changed files with 88 additions and 365 deletions
@@ -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 ModuleDescriptor moduleDescriptor
+        @NotNull BindingTrace bindingTrace
    ) {
        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;
    }
@@ -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;
-    }
-    
-}
@@ -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);
@@ -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);
@@ -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) {
-        this.trace = trace;
+    public void setPsiDeclarationProviderFactory(@NotNull PsiDeclarationProviderFactory psiDeclarationProviderFactory) {
+        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);
-    }
 }
@@ -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);
        }
@@ -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);
        }
@@ -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,
-                                                               JavaToKotlinClassMap.getInstance());
+        ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<test module>");
        NamespaceDescriptorImpl rootNamespace =
                new NamespaceDescriptorImpl(module, Collections.<AnnotationDescriptor>emptyList(), JetPsiUtil.ROOT_NAMESPACE_NAME);
        module.setRootNamespace(rootNamespace);
@@ -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(
-                getProject(), new BindingTraceContext(), moduleDescriptor).getJavaDescriptorResolver();
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext());
+        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();

        NamespaceDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testNamespace);

@@ -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(),
-                                                                                                  trace,
-                                                                                                  moduleDescriptor);
+        InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(), trace);

+        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<test module>");
        InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm(
                environment.getProject(),
                new TopDownAnalysisParameters(
@@ -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);
@@ -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());
-        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        BindingTraceContext trace = new BindingTraceContext();
+        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
@@ -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 {
            }
        }

-
-        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject());
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(
+                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);
                    }
@@ -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 =
-                new InjectorForJavaDescriptorResolver(project, sharedTrace, javaModule);
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, sharedTrace);
        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);
@@ -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;
@@ -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());
@@ -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.addPublicParameter(BindingTrace.class);
-        generator.addPublicParameter(ModuleDescriptor.class);
+        generator.addParameter(Project.class);
+        generator.addParameter(BindingTrace.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();

@@ -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");
@@ -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");
-
-        ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule("<fake>");
-        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, delegatingTrace, moduleDescriptor);
-        moduleDescriptor.setModuleConfiguration(injector.getJavaBridgeConfiguration());
-        return injector;
+        return new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
    }

    @Nullable
@@ -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);
-        bindingContext = injector.getBindingTrace().getBindingContext();
-        javaDescriptorResolver = injector.getJavaDescriptorResolver();
+
+        BindingTraceContext trace = new BindingTraceContext();
+        this.bindingContext = trace.getBindingContext();
+        InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(clsFile.getProject(), trace);
+        this.javaDescriptorResolver = injector.getJavaDescriptorResolver();
    }

    @NotNull
@@ -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);