Refactor JavaDescriptorResolver and *Resolver classes to use DI for dependency management

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

@@ -26,7 +26,16 @@ 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.JavaTypeTransformer;
+import org.jetbrains.jet.lang.resolve.java.resolver.ClassResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.CompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.NamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.ConstructorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.ValueParameterResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.FunctionResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.InnerClassResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.PropertiesResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -42,7 +51,16 @@ public class InjectorForJavaDescriptorResolver {
     private JavaDescriptorResolver javaDescriptorResolver;
     private PsiClassFinderImpl psiClassFinder;
     private JavaTypeTransformer javaTypeTransformer;
+    private ClassResolver classResolver;
+    private JavaAnnotationResolver javaAnnotationResolver;
+    private CompileTimeConstResolver compileTimeConstResolver;
+    private NamespaceResolver namespaceResolver;
     private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
+    private ConstructorResolver constructorResolver;
+    private ValueParameterResolver valueParameterResolver;
+    private FunctionResolver functionResolver;
+    private InnerClassResolver innerClassResolver;
+    private PropertiesResolver propertiesResolver;
 
     public InjectorForJavaDescriptorResolver(
         @NotNull Project project,
@@ -59,7 +77,16 @@ public class InjectorForJavaDescriptorResolver {
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.psiClassFinder = new PsiClassFinderImpl();
         this.javaTypeTransformer = new JavaTypeTransformer();
+        this.classResolver = new ClassResolver();
+        this.javaAnnotationResolver = new JavaAnnotationResolver();
+        this.compileTimeConstResolver = new CompileTimeConstResolver();
+        this.namespaceResolver = new NamespaceResolver();
         this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
+        this.constructorResolver = new ConstructorResolver();
+        this.valueParameterResolver = new ValueParameterResolver();
+        this.functionResolver = new FunctionResolver();
+        this.innerClassResolver = new InnerClassResolver();
+        this.propertiesResolver = new PropertiesResolver();
 
         javaBridgeConfiguration.setBuiltinsScopeExtensionMode(builtinsScopeExtensionMode);
         javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
@@ -70,9 +97,13 @@ public class InjectorForJavaDescriptorResolver {
         this.javaSemanticServices.setTrace(bindingTrace);
         this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
 
-        this.javaDescriptorResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+        this.javaDescriptorResolver.setClassResolver(classResolver);
+        this.javaDescriptorResolver.setConstructorResolver(constructorResolver);
+        this.javaDescriptorResolver.setFunctionResolver(functionResolver);
+        this.javaDescriptorResolver.setInnerClassResolver(innerClassResolver);
+        this.javaDescriptorResolver.setNamespaceResolver(namespaceResolver);
         this.javaDescriptorResolver.setProject(project);
-        this.javaDescriptorResolver.setPsiClassFinder(psiClassFinder);
+        this.javaDescriptorResolver.setPropertiesResolver(propertiesResolver);
         this.javaDescriptorResolver.setSemanticServices(javaSemanticServices);
         this.javaDescriptorResolver.setTrace(bindingTrace);
 
@@ -81,8 +112,47 @@ public class InjectorForJavaDescriptorResolver {
         javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
+        classResolver.setAnnotationResolver(javaAnnotationResolver);
+        classResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        classResolver.setNamespaceResolver(namespaceResolver);
+        classResolver.setPsiClassFinder(psiClassFinder);
+        classResolver.setSemanticServices(javaSemanticServices);
+        classResolver.setSignatureResolver(javaDescriptorSignatureResolver);
+        classResolver.setTrace(bindingTrace);
+        classResolver.setTypeTransformer(javaTypeTransformer);
+
+        javaAnnotationResolver.setClassResolver(classResolver);
+        javaAnnotationResolver.setCompileTimeConstResolver(compileTimeConstResolver);
+
+        compileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
+        compileTimeConstResolver.setClassResolver(classResolver);
+
+        namespaceResolver.setJavaSemanticServices(javaSemanticServices);
+        namespaceResolver.setPsiClassFinder(psiClassFinder);
+        namespaceResolver.setTrace(bindingTrace);
+
         javaDescriptorSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        constructorResolver.setTrace(bindingTrace);
+        constructorResolver.setTypeTransformer(javaTypeTransformer);
+        constructorResolver.setValueParameterResolver(valueParameterResolver);
+
+        valueParameterResolver.setTypeTransformer(javaTypeTransformer);
+
+        functionResolver.setAnnotationResolver(javaAnnotationResolver);
+        functionResolver.setParameterResolver(valueParameterResolver);
+        functionResolver.setSignatureResolver(javaDescriptorSignatureResolver);
+        functionResolver.setTrace(bindingTrace);
+        functionResolver.setTypeTransformer(javaTypeTransformer);
+
+        innerClassResolver.setClassResolver(classResolver);
+
+        propertiesResolver.setAnnotationResolver(javaAnnotationResolver);
+        propertiesResolver.setClassResolver(classResolver);
+        propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+        propertiesResolver.setSemanticServices(javaSemanticServices);
+        propertiesResolver.setTrace(bindingTrace);
+
         javaBridgeConfiguration.init();
 
         psiClassFinder.initialize();

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

@@ -26,7 +26,16 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
+import org.jetbrains.jet.lang.resolve.java.resolver.ClassResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.CompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.NamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.ConstructorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.ValueParameterResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.FunctionResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.InnerClassResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.PropertiesResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -42,7 +51,16 @@ public class InjectorForJavaSemanticServices {
     private final BuiltinsScopeExtensionMode builtinsScopeExtensionMode;
     private final Project project;
     private JavaTypeTransformer javaTypeTransformer;
+    private ClassResolver classResolver;
+    private JavaAnnotationResolver javaAnnotationResolver;
+    private CompileTimeConstResolver compileTimeConstResolver;
+    private NamespaceResolver namespaceResolver;
     private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
+    private ConstructorResolver constructorResolver;
+    private ValueParameterResolver valueParameterResolver;
+    private FunctionResolver functionResolver;
+    private InnerClassResolver innerClassResolver;
+    private PropertiesResolver propertiesResolver;
 
     public InjectorForJavaSemanticServices(
         @NotNull BuiltinsScopeExtensionMode builtinsScopeExtensionMode,
@@ -57,16 +75,29 @@ public class InjectorForJavaSemanticServices {
         this.builtinsScopeExtensionMode = builtinsScopeExtensionMode;
         this.project = project;
         this.javaTypeTransformer = new JavaTypeTransformer();
+        this.classResolver = new ClassResolver();
+        this.javaAnnotationResolver = new JavaAnnotationResolver();
+        this.compileTimeConstResolver = new CompileTimeConstResolver();
+        this.namespaceResolver = new NamespaceResolver();
         this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
+        this.constructorResolver = new ConstructorResolver();
+        this.valueParameterResolver = new ValueParameterResolver();
+        this.functionResolver = new FunctionResolver();
+        this.innerClassResolver = new InnerClassResolver();
+        this.propertiesResolver = new PropertiesResolver();
 
         this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
         this.javaSemanticServices.setPsiClassFinder(psiClassFinder);
         this.javaSemanticServices.setTrace(bindingTrace);
         this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
 
-        this.javaDescriptorResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+        this.javaDescriptorResolver.setClassResolver(classResolver);
+        this.javaDescriptorResolver.setConstructorResolver(constructorResolver);
+        this.javaDescriptorResolver.setFunctionResolver(functionResolver);
+        this.javaDescriptorResolver.setInnerClassResolver(innerClassResolver);
+        this.javaDescriptorResolver.setNamespaceResolver(namespaceResolver);
         this.javaDescriptorResolver.setProject(project);
-        this.javaDescriptorResolver.setPsiClassFinder(psiClassFinder);
+        this.javaDescriptorResolver.setPropertiesResolver(propertiesResolver);
         this.javaDescriptorResolver.setSemanticServices(javaSemanticServices);
         this.javaDescriptorResolver.setTrace(bindingTrace);
 
@@ -79,8 +110,47 @@ public class InjectorForJavaSemanticServices {
         javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
+        classResolver.setAnnotationResolver(javaAnnotationResolver);
+        classResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        classResolver.setNamespaceResolver(namespaceResolver);
+        classResolver.setPsiClassFinder(psiClassFinder);
+        classResolver.setSemanticServices(javaSemanticServices);
+        classResolver.setSignatureResolver(javaDescriptorSignatureResolver);
+        classResolver.setTrace(bindingTrace);
+        classResolver.setTypeTransformer(javaTypeTransformer);
+
+        javaAnnotationResolver.setClassResolver(classResolver);
+        javaAnnotationResolver.setCompileTimeConstResolver(compileTimeConstResolver);
+
+        compileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
+        compileTimeConstResolver.setClassResolver(classResolver);
+
+        namespaceResolver.setJavaSemanticServices(javaSemanticServices);
+        namespaceResolver.setPsiClassFinder(psiClassFinder);
+        namespaceResolver.setTrace(bindingTrace);
+
         javaDescriptorSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        constructorResolver.setTrace(bindingTrace);
+        constructorResolver.setTypeTransformer(javaTypeTransformer);
+        constructorResolver.setValueParameterResolver(valueParameterResolver);
+
+        valueParameterResolver.setTypeTransformer(javaTypeTransformer);
+
+        functionResolver.setAnnotationResolver(javaAnnotationResolver);
+        functionResolver.setParameterResolver(valueParameterResolver);
+        functionResolver.setSignatureResolver(javaDescriptorSignatureResolver);
+        functionResolver.setTrace(bindingTrace);
+        functionResolver.setTypeTransformer(javaTypeTransformer);
+
+        innerClassResolver.setClassResolver(classResolver);
+
+        propertiesResolver.setAnnotationResolver(javaAnnotationResolver);
+        propertiesResolver.setClassResolver(classResolver);
+        propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+        propertiesResolver.setSemanticServices(javaSemanticServices);
+        propertiesResolver.setTrace(bindingTrace);
+
         javaBridgeConfiguration.init();
 
         psiClassFinder.initialize();

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

@@ -48,7 +48,16 @@ import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
+import org.jetbrains.jet.lang.resolve.java.resolver.ClassResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.CompileTimeConstResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.NamespaceResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.ConstructorResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.ValueParameterResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.FunctionResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.InnerClassResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.PropertiesResolver;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -85,7 +94,16 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private ScriptBodyResolver scriptBodyResolver;
     private JavaSemanticServices javaSemanticServices;
     private JavaTypeTransformer javaTypeTransformer;
+    private ClassResolver classResolver;
+    private JavaAnnotationResolver javaAnnotationResolver;
+    private CompileTimeConstResolver compileTimeConstResolver;
+    private NamespaceResolver namespaceResolver;
     private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
+    private ConstructorResolver constructorResolver;
+    private ValueParameterResolver valueParameterResolver;
+    private FunctionResolver functionResolver;
+    private InnerClassResolver innerClassResolver;
+    private PropertiesResolver propertiesResolver;
 
     public InjectorForTopDownAnalyzerForJvm(
         @NotNull Project project,
@@ -124,7 +142,16 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.javaSemanticServices = new JavaSemanticServices();
         this.javaTypeTransformer = new JavaTypeTransformer();
+        this.classResolver = new ClassResolver();
+        this.javaAnnotationResolver = new JavaAnnotationResolver();
+        this.compileTimeConstResolver = new CompileTimeConstResolver();
+        this.namespaceResolver = new NamespaceResolver();
         this.javaDescriptorSignatureResolver = new JavaDescriptorSignatureResolver();
+        this.constructorResolver = new ConstructorResolver();
+        this.valueParameterResolver = new ValueParameterResolver();
+        this.functionResolver = new FunctionResolver();
+        this.innerClassResolver = new InnerClassResolver();
+        this.propertiesResolver = new PropertiesResolver();
 
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setContext(topDownAnalysisContext);
@@ -162,9 +189,13 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.moduleConfiguration.setJavaSemanticServices(javaSemanticServices);
         this.moduleConfiguration.setProject(project);
 
-        javaDescriptorResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+        javaDescriptorResolver.setClassResolver(classResolver);
+        javaDescriptorResolver.setConstructorResolver(constructorResolver);
+        javaDescriptorResolver.setFunctionResolver(functionResolver);
+        javaDescriptorResolver.setInnerClassResolver(innerClassResolver);
+        javaDescriptorResolver.setNamespaceResolver(namespaceResolver);
         javaDescriptorResolver.setProject(project);
-        javaDescriptorResolver.setPsiClassFinder(psiClassFinder);
+        javaDescriptorResolver.setPropertiesResolver(propertiesResolver);
         javaDescriptorResolver.setSemanticServices(javaSemanticServices);
         javaDescriptorResolver.setTrace(bindingTrace);
 
@@ -236,8 +267,47 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
         javaTypeTransformer.setResolver(javaDescriptorResolver);
 
+        classResolver.setAnnotationResolver(javaAnnotationResolver);
+        classResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        classResolver.setNamespaceResolver(namespaceResolver);
+        classResolver.setPsiClassFinder(psiClassFinder);
+        classResolver.setSemanticServices(javaSemanticServices);
+        classResolver.setSignatureResolver(javaDescriptorSignatureResolver);
+        classResolver.setTrace(bindingTrace);
+        classResolver.setTypeTransformer(javaTypeTransformer);
+
+        javaAnnotationResolver.setClassResolver(classResolver);
+        javaAnnotationResolver.setCompileTimeConstResolver(compileTimeConstResolver);
+
+        compileTimeConstResolver.setAnnotationResolver(javaAnnotationResolver);
+        compileTimeConstResolver.setClassResolver(classResolver);
+
+        namespaceResolver.setJavaSemanticServices(javaSemanticServices);
+        namespaceResolver.setPsiClassFinder(psiClassFinder);
+        namespaceResolver.setTrace(bindingTrace);
+
         javaDescriptorSignatureResolver.setJavaSemanticServices(javaSemanticServices);
 
+        constructorResolver.setTrace(bindingTrace);
+        constructorResolver.setTypeTransformer(javaTypeTransformer);
+        constructorResolver.setValueParameterResolver(valueParameterResolver);
+
+        valueParameterResolver.setTypeTransformer(javaTypeTransformer);
+
+        functionResolver.setAnnotationResolver(javaAnnotationResolver);
+        functionResolver.setParameterResolver(valueParameterResolver);
+        functionResolver.setSignatureResolver(javaDescriptorSignatureResolver);
+        functionResolver.setTrace(bindingTrace);
+        functionResolver.setTypeTransformer(javaTypeTransformer);
+
+        innerClassResolver.setClassResolver(classResolver);
+
+        propertiesResolver.setAnnotationResolver(javaAnnotationResolver);
+        propertiesResolver.setClassResolver(classResolver);
+        propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+        propertiesResolver.setSemanticServices(javaSemanticServices);
+        propertiesResolver.setTrace(bindingTrace);
+
         moduleConfiguration.init();
 
         psiClassFinder.initialize();

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

@@ -17,22 +17,16 @@
 package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.openapi.project.Project;
-import com.intellij.psi.PsiAnnotation;
-import com.intellij.psi.PsiAnnotationMemberValue;
 import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiModifierListOwner;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.resolver.*;
 import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiParameterWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver;
@@ -70,17 +64,12 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     protected Project project;
     protected JavaSemanticServices semanticServices;
     private BindingTrace trace;
-    private PsiClassFinder psiClassFinder;
+    private PropertiesResolver propertiesResolver;
-    private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
+    private ClassResolver classResolver;
-    private final PropertiesResolver propertiesResolver = new PropertiesResolver(this);
+    private ConstructorResolver constructorResolver;
-    private final ClassResolver classResolver = new ClassResolver(this);
+    private FunctionResolver functionResolver;
-    private final ConstructorResolver constructorResolver = new ConstructorResolver(this);
+    private NamespaceResolver namespaceResolver;
-    private final CompileTimeConstResolver compileTimeConstResolver = new CompileTimeConstResolver(this);
+    private InnerClassResolver innerClassResolver;
-    private final JavaAnnotationResolver annotationResolver = new JavaAnnotationResolver(this);
-    private final FunctionResolver functionResolver = new FunctionResolver(this);
-    private final NamespaceResolver namespaceResolver = new NamespaceResolver(this);
-    private final InnerClassResolver innerClassResolver = new InnerClassResolver(this);
-    private final ValueParameterResolver valueParameterResolver = new ValueParameterResolver(this);
 
     @Inject
     public void setProject(Project project) {
@@ -90,24 +79,41 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
     @Inject
     public void setSemanticServices(JavaSemanticServices semanticServices) {
         this.semanticServices = semanticServices;
-        this.propertiesResolver.setSemanticServices(semanticServices);
     }
 
     @Inject
     public void setTrace(BindingTrace trace) {
         this.trace = trace;
-        this.propertiesResolver.setTrace(trace);
     }
 
     @Inject
-    public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
+    public void setFunctionResolver(FunctionResolver functionResolver) {
-        this.psiClassFinder = psiClassFinder;
+        this.functionResolver = functionResolver;
     }
 
     @Inject
-    public void setJavaDescriptorSignatureResolver(JavaDescriptorSignatureResolver javaDescriptorSignatureResolver) {
+    public void setClassResolver(ClassResolver classResolver) {
-        this.javaDescriptorSignatureResolver = javaDescriptorSignatureResolver;
+        this.classResolver = classResolver;
-        this.propertiesResolver.setJavaDescriptorSignatureResolver(javaDescriptorSignatureResolver);
+    }
+
+    @Inject
+    public void setNamespaceResolver(NamespaceResolver namespaceResolver) {
+        this.namespaceResolver = namespaceResolver;
+    }
+
+    @Inject
+    public void setPropertiesResolver(PropertiesResolver propertiesResolver) {
+        this.propertiesResolver = propertiesResolver;
+    }
+
+    @Inject
+    public void setConstructorResolver(ConstructorResolver constructorResolver) {
+        this.constructorResolver = constructorResolver;
+    }
+
+    @Inject
+    public void setInnerClassResolver(InnerClassResolver innerClassResolver) {
+        this.innerClassResolver = innerClassResolver;
     }
 
     @Nullable
@@ -117,19 +123,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
 
     @Override
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
-        return classResolver.resolveClass(qualifiedName, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
+        return classResolver.resolveClass(qualifiedName);
-    }
-
-    public PsiClassFinder getPsiClassFinder() {
-        return psiClassFinder;
-    }
-
-    public JavaDescriptorSignatureResolver getJavaDescriptorSignatureResolver() {
-        return javaDescriptorSignatureResolver;
-    }
-
-    public JavaSemanticServices getSemanticServices() {
-        return semanticServices;
     }
 
     public BindingTrace getTrace() {
@@ -169,16 +163,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return classResolver.resolveClass(name, searchRule, list);
     }
 
-    @Nullable
-    public CompileTimeConstant getCompileTimeConstFromExpression(
-            FqName annotationName,
-            Name parameterName,
-            PsiAnnotationMemberValue value,
-            List<Runnable> taskList
-    ) {
-        return compileTimeConstResolver.getCompileTimeConstFromExpression(annotationName, parameterName, value, taskList);
-    }
-
     public static class ValueParameterDescriptors {
         private final JetType receiverType;
         private final List<ValueParameterDescriptor> descriptors;
@@ -204,26 +188,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes
         return functionResolver.resolveFunctionGroup(methodName, scopeData);
     }
 
-    public ValueParameterDescriptors resolveParameterDescriptors(
-            DeclarationDescriptor containingDeclaration,
-            List<PsiParameterWrapper> parameters, TypeVariableResolver typeVariableResolver
-    ) {
-        return valueParameterResolver.resolveParameterDescriptors(containingDeclaration, parameters, typeVariableResolver);
-    }
-
-    public List<AnnotationDescriptor> resolveAnnotations(PsiModifierListOwner owner, @NotNull List<Runnable> tasks) {
-        return annotationResolver.resolveAnnotations(owner, tasks);
-    }
-
-    public List<AnnotationDescriptor> resolveAnnotations(PsiModifierListOwner owner) {
-        return annotationResolver.resolveAnnotations(owner);
-    }
-
-    @Nullable
-    public AnnotationDescriptor resolveAnnotation(PsiAnnotation psiAnnotation, @NotNull List<Runnable> taskList) {
-        return annotationResolver.resolveAnnotation(psiAnnotation, taskList);
-    }
-
     public List<FunctionDescriptor> resolveMethods(@NotNull ResolverScopeData scopeData) {
         return functionResolver.resolveMethods(scopeData);
     }

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

@@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverBinaryClassData;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
@@ -52,6 +53,7 @@ import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter;
 import org.jetbrains.jet.rt.signature.JetSignatureReader;
 import org.jetbrains.jet.rt.signature.JetSignatureVisitor;
 
+import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.jet.lang.resolve.DescriptorResolver.createEnumClassObjectValueOfMethod;
@@ -60,8 +62,6 @@ import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName;
 
 public final class ClassResolver {
 
-    private final JavaDescriptorResolver javaDescriptorResolver;
-
     // NOTE: this complexity is introduced because class descriptors do not always have valid fqnames (class objects)
     private final Map<FqNameBase, ResolverClassData> classDescriptorCache =
             new THashMap<FqNameBase, ResolverClassData>(new TObjectHashingStrategy<FqNameBase>() {
@@ -80,10 +80,58 @@ public final class ClassResolver {
                 }
             });
 
-    public ClassResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    private BindingTrace trace;
+    private JavaDescriptorResolver javaDescriptorResolver;
+    private JavaDescriptorSignatureResolver signatureResolver;
+    private JavaSemanticServices semanticServices;
+    private JavaAnnotationResolver annotationResolver;
+    private PsiClassFinder psiClassFinder;
+    private NamespaceResolver namespaceResolver;
+    private JavaTypeTransformer typeTransformer;
+
+    public ClassResolver() {
+    }
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Inject
+    public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) {
         this.javaDescriptorResolver = javaDescriptorResolver;
     }
 
+    @Inject
+    public void setSignatureResolver(JavaDescriptorSignatureResolver signatureResolver) {
+        this.signatureResolver = signatureResolver;
+    }
+
+    @Inject
+    public void setSemanticServices(JavaSemanticServices semanticServices) {
+        this.semanticServices = semanticServices;
+    }
+
+    @Inject
+    public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
+        this.annotationResolver = annotationResolver;
+    }
+
+    @Inject
+    public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
+        this.psiClassFinder = psiClassFinder;
+    }
+
+    @Inject
+    public void setNamespaceResolver(NamespaceResolver namespaceResolver) {
+        this.namespaceResolver = namespaceResolver;
+    }
+
+    @Inject
+    public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
+    }
+
     @Nullable
     public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         List<Runnable> tasks = Lists.newArrayList();
@@ -106,13 +154,13 @@ public final class ClassResolver {
         }
 
         ClassDescriptor builtinClassDescriptor =
-                javaDescriptorResolver.getSemanticServices().getKotlinBuiltinClassDescriptor(qualifiedName);
+                semanticServices.getKotlinBuiltinClassDescriptor(qualifiedName);
         if (builtinClassDescriptor != null) {
             return builtinClassDescriptor;
         }
 
         // First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
-        ClassDescriptor kotlinClassDescriptor = javaDescriptorResolver.getSemanticServices().getKotlinClassDescriptor(qualifiedName);
+        ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
         if (kotlinClassDescriptor != null) {
             return searchRule.processFoundInKotlin(kotlinClassDescriptor);
         }
@@ -121,7 +169,7 @@ public final class ClassResolver {
         ResolverClassData classData = classDescriptorCache.get(qualifiedName);
         if (classData == null) {
             PsiClass psiClass =
-                    javaDescriptorResolver.getPsiClassFinder().findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
+                    psiClassFinder.findPsiClass(qualifiedName, PsiClassFinder.RuntimeClassesHandleMode.THROW);
             if (psiClass == null) {
                 ResolverClassData oldValue =
                         classDescriptorCache
@@ -171,7 +219,7 @@ public final class ClassResolver {
         List<JetType> supertypes = new ArrayList<JetType>();
 
         List<JavaDescriptorSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
-                = javaDescriptorResolver.getJavaDescriptorSignatureResolver().createUninitializedClassTypeParameters(psiClass, classData);
+                = signatureResolver.createUninitializedClassTypeParameters(psiClass, classData);
 
         List<TypeParameterDescriptor> typeParameters = new ArrayList<TypeParameterDescriptor>();
         for (JavaDescriptorSignatureResolver.TypeParameterDescriptorInitialization typeParameter : typeParameterDescriptorInitializations) {
@@ -193,9 +241,9 @@ public final class ClassResolver {
         classData.getClassDescriptor().setModality(modality);
         classData.getClassDescriptor().createTypeConstructor();
         classData.getClassDescriptor()
-                .setScopeForMemberLookup(new JavaClassMembersScope(javaDescriptorResolver.getSemanticServices(), classData));
+                .setScopeForMemberLookup(new JavaClassMembersScope(semanticServices, classData));
 
-        javaDescriptorResolver.getJavaDescriptorSignatureResolver()
+        signatureResolver
                 .initializeTypeParameters(typeParameterDescriptorInitializations, classData.getClassDescriptor(), "class " + qualifiedName);
 
         // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
@@ -207,7 +255,7 @@ public final class ClassResolver {
             classData.getClassDescriptor().getBuilder().setClassObjectDescriptor(classObject);
         }
 
-        classData.getClassDescriptor().setAnnotations(javaDescriptorResolver.resolveAnnotations(psiClass, taskList));
+        classData.getClassDescriptor().setAnnotations(annotationResolver.resolveAnnotations(psiClass, taskList));
 
         javaDescriptorResolver.getTrace().record(BindingContext.CLASS, psiClass, classData.getClassDescriptor());
 
@@ -268,7 +316,7 @@ public final class ClassResolver {
         classDescriptor.setVisibility(containing.getVisibility());
         classDescriptor.setTypeParameterDescriptors(Collections.<TypeParameterDescriptor>emptyList());
         classDescriptor.createTypeConstructor();
-        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(javaDescriptorResolver.getSemanticServices(), data);
+        JavaClassMembersScope classMembersScope = new JavaClassMembersScope(semanticServices, data);
         WritableScopeImpl writableScope =
                 new WritableScopeImpl(classMembersScope, classDescriptor, RedeclarationHandler.THROW_EXCEPTION, fqName.toString());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
@@ -283,9 +331,9 @@ public final class ClassResolver {
         MutableClassDescriptorLite classObjectDescriptor = createSyntheticClassObject(containing, psiClass);
 
         classObjectDescriptor.getBuilder()
-                .addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, javaDescriptorResolver.getTrace()));
+                .addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace));
         classObjectDescriptor.getBuilder()
-                .addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, javaDescriptorResolver.getTrace()));
+                .addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace));
 
         return classObjectDescriptor;
     }
@@ -332,7 +380,7 @@ public final class ClassResolver {
 
                 @Override
                 public JetSignatureVisitor visitSuperclass() {
-                    return new JetTypeJetSignatureReader(javaDescriptorResolver.getSemanticServices(), JetStandardLibrary.getInstance(),
+                    return new JetTypeJetSignatureReader(semanticServices, JetStandardLibrary.getInstance(),
                                                          typeVariableResolver) {
                         @Override
                         protected void done(@NotNull JetType jetType) {
@@ -358,7 +406,7 @@ public final class ClassResolver {
 
         for (JetType supertype : result) {
             if (ErrorUtils.isErrorType(supertype)) {
-                javaDescriptorResolver.getTrace().record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor);
+                trace.record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor);
             }
         }
 
@@ -397,7 +445,7 @@ public final class ClassResolver {
                 }
             }
 
-            JetType transform = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
+            JetType transform = typeTransformer
                     .transformToType(type, JavaTypeTransformer.TypeUsage.SUPERTYPE, typeVariableResolver);
             if (ErrorUtils.isErrorType(transform)) {
                 continue;
@@ -433,7 +481,7 @@ public final class ClassResolver {
             return clazz;
         }
 
-        NamespaceDescriptor ns = javaDescriptorResolver.resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
+        NamespaceDescriptor ns = namespaceResolver.resolveNamespace(fqName.parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
         if (ns == null) {
             throw new IllegalStateException("cannot resolve namespace " + fqName.parent() + ", required to be container for " + fqName);
         }
@@ -472,4 +520,10 @@ public final class ClassResolver {
         }
         return null;
     }
+
+
+    @Nullable
+    public ClassDescriptor resolveClass(FqName name) {
+        return resolveClass(name, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
+    }
 }

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

@@ -28,22 +28,32 @@ import org.jetbrains.jet.lang.resolve.constants.*;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 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;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeProjection;
 
+import javax.inject.Inject;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
 public final class CompileTimeConstResolver {
-    private final JavaDescriptorResolver javaDescriptorResolver;
+    private JavaAnnotationResolver annotationResolver;
+    private ClassResolver classResolver;
 
-    public CompileTimeConstResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    public CompileTimeConstResolver() {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+    }
+
+    @Inject
+    public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
+        this.annotationResolver = annotationResolver;
+    }
+
+    @Inject
+    public void setClassResolver(ClassResolver classResolver) {
+        this.classResolver = classResolver;
     }
 
     @Nullable
@@ -72,7 +82,7 @@ public final class CompileTimeConstResolver {
 
     @Nullable
     private CompileTimeConstant<?> getCompileTimeConstFromAnnotation(PsiAnnotation value, List<Runnable> taskList) {
-        AnnotationDescriptor annotationDescriptor = javaDescriptorResolver.resolveAnnotation(value, taskList);
+        AnnotationDescriptor annotationDescriptor = annotationResolver.resolveAnnotation(value, taskList);
         if (annotationDescriptor != null) {
             return new AnnotationValue(annotationDescriptor);
         }
@@ -89,7 +99,7 @@ public final class CompileTimeConstResolver {
         List<CompileTimeConstant<?>> values = getCompileTimeConstantForArrayValues(annotationFqName, valueName, taskList, initializers);
 
         ClassDescriptor classDescriptor =
-                javaDescriptorResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
+                classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
 
         ValueParameterDescriptor valueParameterDescriptor =
                 DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(valueName, classDescriptor);
@@ -131,8 +141,7 @@ public final class CompileTimeConstResolver {
                 }
 
                 JetScope scope;
-                ClassDescriptor classDescriptor =
+                ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(fqName), DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
-                        javaDescriptorResolver.resolveClass(new FqName(fqName), DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
                 if (classDescriptor == null) {
                     return null;
                 }

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

@@ -23,11 +23,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.TypeVariableResolver;
-import org.jetbrains.jet.lang.resolve.java.TypeVariableResolvers;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverClassData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
@@ -35,15 +33,32 @@ import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 
+import javax.inject.Inject;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
 public final class ConstructorResolver {
-    private final JavaDescriptorResolver javaDescriptorResolver;
+    private BindingTrace trace;
+    private JavaTypeTransformer typeTransformer;
+    private ValueParameterResolver valueParameterResolver;
 
-    public ConstructorResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    public ConstructorResolver() {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+    }
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Inject
+    public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
+    }
+
+    @Inject
+    public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) {
+        this.valueParameterResolver = valueParameterResolver;
     }
 
     @NotNull
@@ -66,8 +81,8 @@ public final class ConstructorResolver {
             constructors.add(DescriptorResolver.createPrimaryConstructorForObject(containingClass));
         }
         else if (psiConstructors.length == 0) {
-            if (javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiClass) != null) {
+            if (trace.get(BindingContext.CONSTRUCTOR, psiClass) != null) {
-                constructors.add(javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiClass));
+                constructors.add(trace.get(BindingContext.CONSTRUCTOR, psiClass));
             }
             else {
                 // We need to create default constructors for classes and abstract classes.
@@ -82,7 +97,7 @@ public final class ConstructorResolver {
                     constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), containingClass
                             .getVisibility(), isStatic);
                     constructors.add(constructorDescriptor);
-                    javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
+                    trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
                 }
                 if (psiClass.isAnnotationType()) {
                     // A constructor for an annotation type takes all the "methods" in the @interface as parameters
@@ -105,7 +120,7 @@ public final class ConstructorResolver {
                             // if the last method of the @interface is an array, we convert it into a vararg
                             JetType varargElementType = null;
                             if (i == methods.length - 1 && (returnType instanceof PsiArrayType)) {
-                                varargElementType = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
+                                varargElementType = typeTransformer
                                         .transformToType(((PsiArrayType) returnType).getComponentType(), resolverForTypeParameters);
                             }
 
@@ -116,8 +131,7 @@ public final class ConstructorResolver {
                                     Collections.<AnnotationDescriptor>emptyList(),
                                     Name.identifier(method.getName()),
                                     false,
-                                    javaDescriptorResolver.getSemanticServices().getTypeTransformer()
+                                    typeTransformer.transformToType(returnType, resolverForTypeParameters),
-                                            .transformToType(returnType, resolverForTypeParameters),
                                     annotationMethod.getDefaultValue() != null,
                                     varargElementType));
                         }
@@ -125,7 +139,7 @@ public final class ConstructorResolver {
 
                     constructorDescriptor.initialize(typeParameters, valueParameters, containingClass.getVisibility(), isStatic);
                     constructors.add(constructorDescriptor);
-                    javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
+                    trace.record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
                 }
             }
         }
@@ -159,8 +173,8 @@ public final class ConstructorResolver {
             return null;
         }
 
-        if (javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiConstructor) != null) {
+        if (trace.get(BindingContext.CONSTRUCTOR, psiConstructor) != null) {
-            return javaDescriptorResolver.getTrace().get(BindingContext.CONSTRUCTOR, psiConstructor);
+            return trace.get(BindingContext.CONSTRUCTOR, psiConstructor);
         }
 
         ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(
@@ -169,7 +183,7 @@ public final class ConstructorResolver {
                 false);
 
         String context = "constructor of class " + psiClass.getQualifiedName();
-        JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = javaDescriptorResolver.resolveParameterDescriptors(
+        JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors(
                 constructorDescriptor, constructor.getParameters(),
                 TypeVariableResolvers.classTypeVariableResolver(classData.getClassDescriptor(), context));
 
@@ -184,15 +198,15 @@ public final class ConstructorResolver {
             valueParameterDescriptors = alternativeMethodSignatureData.getValueParameters();
         }
         else if (alternativeMethodSignatureData.hasErrors()) {
-            javaDescriptorResolver.getTrace().record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, constructorDescriptor,
+            trace.record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, constructorDescriptor,
-                                                     alternativeMethodSignatureData.getError());
+                         alternativeMethodSignatureData.getError());
         }
 
         constructorDescriptor.initialize(classData.getClassDescriptor().getTypeConstructor().getParameters(),
                                          valueParameterDescriptors.getDescriptors(),
                                          DescriptorResolverUtils.resolveVisibility(psiConstructor, constructor.getJetConstructor()),
                                          aStatic);
-        javaDescriptorResolver.getTrace().record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
+        trace.record(BindingContext.CONSTRUCTOR, psiConstructor, constructorDescriptor);
         return constructorDescriptor;
     }
 }

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

@@ -24,10 +24,7 @@ import com.intellij.psi.PsiType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.BindingContextUtils;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData;
 import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData;
@@ -39,13 +36,43 @@ import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
+import javax.inject.Inject;
 import java.util.*;
 
 public final class FunctionResolver {
-    private final JavaDescriptorResolver javaDescriptorResolver;
 
-    public FunctionResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    private JavaTypeTransformer typeTransformer;
-        this.javaDescriptorResolver = javaDescriptorResolver;
+    private BindingTrace trace;
+    private JavaDescriptorSignatureResolver signatureResolver;
+    private ValueParameterResolver parameterResolver;
+    private JavaAnnotationResolver annotationResolver;
+
+    public FunctionResolver() {
+    }
+
+    @Inject
+    public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
+    }
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Inject
+    public void setSignatureResolver(JavaDescriptorSignatureResolver signatureResolver) {
+        this.signatureResolver = signatureResolver;
+    }
+
+    @Inject
+    public void setParameterResolver(ValueParameterResolver parameterResolver) {
+        this.parameterResolver = parameterResolver;
+    }
+
+    @Inject
+    public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
+        this.annotationResolver = annotationResolver;
     }
 
     @Nullable
@@ -77,13 +104,13 @@ public final class FunctionResolver {
             }
         }
 
-        if (javaDescriptorResolver.getTrace().get(BindingContext.FUNCTION, psiMethod) != null) {
+        if (trace.get(BindingContext.FUNCTION, psiMethod) != null) {
-            return javaDescriptorResolver.getTrace().get(BindingContext.FUNCTION, psiMethod);
+            return trace.get(BindingContext.FUNCTION, psiMethod);
         }
 
         SimpleFunctionDescriptorImpl functionDescriptorImpl = new SimpleFunctionDescriptorImpl(
                 scopeData.getClassOrNamespaceDescriptor(),
-                javaDescriptorResolver.resolveAnnotations(psiMethod),
+                annotationResolver.resolveAnnotations(psiMethod),
                 Name.identifier(method.getName()),
                 DescriptorKindUtils.flagsToKind(method.getJetMethod().kind())
         );
@@ -91,15 +118,15 @@ public final class FunctionResolver {
         String context = "method " + method.getName() + " in class " + psiClass.getQualifiedName();
 
         List<TypeParameterDescriptor> methodTypeParameters =
-                javaDescriptorResolver.getJavaDescriptorSignatureResolver().resolveMethodTypeParameters(method,
+                signatureResolver.resolveMethodTypeParameters(method,
-                                                                                                        functionDescriptorImpl);
+                                                                  functionDescriptorImpl);
 
         TypeVariableResolver methodTypeVariableResolver = TypeVariableResolvers.typeVariableResolverFromTypeParameters(methodTypeParameters,
                                                                                                                        functionDescriptorImpl,
                                                                                                                        context);
 
 
-        JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = javaDescriptorResolver
+        JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = parameterResolver
                 .resolveParameterDescriptors(functionDescriptorImpl, method.getParameters(), methodTypeVariableResolver);
         JetType returnType = makeReturnType(returnPsiType, method, methodTypeVariableResolver);
 
@@ -112,8 +139,8 @@ public final class FunctionResolver {
             methodTypeParameters = alternativeMethodSignatureData.getTypeParameters();
         }
         else if (alternativeMethodSignatureData.hasErrors()) {
-            javaDescriptorResolver.getTrace().record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, functionDescriptorImpl,
+            trace.record(BindingContext.ALTERNATIVE_SIGNATURE_DATA_ERROR, functionDescriptorImpl,
-                                                     alternativeMethodSignatureData.getError());
+                         alternativeMethodSignatureData.getError());
         }
 
         functionDescriptorImpl.initialize(
@@ -128,11 +155,11 @@ public final class FunctionResolver {
         );
 
         if (functionDescriptorImpl.getKind() == CallableMemberDescriptor.Kind.DECLARATION) {
-            BindingContextUtils.recordFunctionDeclarationToDescriptor(javaDescriptorResolver.getTrace(), psiMethod, functionDescriptorImpl);
+            BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, psiMethod, functionDescriptorImpl);
         }
 
         if (!scopeData.isKotlin()) {
-            javaDescriptorResolver.getTrace().record(BindingContext.IS_DECLARED_IN_JAVA, functionDescriptorImpl);
+            trace.record(BindingContext.IS_DECLARED_IN_JAVA, functionDescriptorImpl);
         }
 
         if (containingClass != psiClass && !method.isStatic()) {
@@ -181,7 +208,7 @@ public final class FunctionResolver {
                                                               });
         }
 
-        OverrideResolver.resolveUnknownVisibilities(functions, javaDescriptorResolver.getTrace());
+        OverrideResolver.resolveUnknownVisibilities(functions, trace);
         functions.addAll(functionsFromCurrent);
 
         if (DescriptorUtils.isEnumClassObject(owner)) {
@@ -227,11 +254,10 @@ public final class FunctionResolver {
 
         JetType transformedType;
         if (returnTypeFromAnnotation.length() > 0) {
-            transformedType = javaDescriptorResolver.getSemanticServices()
+            transformedType = typeTransformer.transformToType(returnTypeFromAnnotation, typeVariableResolver);
-                    .getTypeTransformer().transformToType(returnTypeFromAnnotation, typeVariableResolver);
         }
         else {
-            transformedType = javaDescriptorResolver.getSemanticServices().getTypeTransformer().transformToType(
+            transformedType = typeTransformer.transformToType(
                     returnType, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT, typeVariableResolver);
         }
 

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

@@ -24,18 +24,23 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
+import javax.inject.Inject;
 import java.util.ArrayList;
 import java.util.List;
 
 public final class InnerClassResolver {
-    private final JavaDescriptorResolver javaDescriptorResolver;
 
-    public InnerClassResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    private ClassResolver classResolver;
-        this.javaDescriptorResolver = javaDescriptorResolver;
+
+    public InnerClassResolver() {
+    }
+
+    @Inject
+    public void setClassResolver(ClassResolver classResolver) {
+        this.classResolver = classResolver;
     }
 
     public List<ClassDescriptor> resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) {
@@ -83,8 +88,7 @@ public final class InnerClassResolver {
     private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) {
         String name = innerPsiClass.getQualifiedName();
         assert name != null : "Inner class has no qualified name";
-        ClassDescriptor classDescriptor =
+        ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
-                javaDescriptorResolver.resolveClass(new FqName(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         assert classDescriptor != null : "Couldn't resolve class " + name;
         return classDescriptor;
     }

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

@@ -27,20 +27,30 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import javax.inject.Inject;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 public final class JavaAnnotationResolver {
-    private final JavaDescriptorResolver javaDescriptorResolver;
+    private ClassResolver classResolver;
+    private CompileTimeConstResolver compileTimeConstResolver;
 
-    public JavaAnnotationResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    public JavaAnnotationResolver() {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+    }
+
+    @Inject
+    public void setClassResolver(ClassResolver classResolver) {
+        this.classResolver = classResolver;
+    }
+
+    @Inject
+    public void setCompileTimeConstResolver(CompileTimeConstResolver compileTimeConstResolver) {
+        this.compileTimeConstResolver = compileTimeConstResolver;
     }
 
     public List<AnnotationDescriptor> resolveAnnotations(PsiModifierListOwner owner, @NotNull List<Runnable> tasks) {
@@ -79,7 +89,7 @@ public final class JavaAnnotationResolver {
 
         FqName annotationFqName = new FqName(qname);
         final ClassDescriptor clazz =
-                javaDescriptorResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
+                classResolver.resolveClass(annotationFqName, DescriptorSearchRule.INCLUDE_KOTLIN, taskList);
         if (clazz == null) {
             return null;
         }
@@ -101,7 +111,7 @@ public final class JavaAnnotationResolver {
 
             assert value != null;
             CompileTimeConstant compileTimeConst =
-                    javaDescriptorResolver.getCompileTimeConstFromExpression(annotationFqName, identifier, value, taskList);
+                    compileTimeConstResolver.getCompileTimeConstFromExpression(annotationFqName, identifier, value, taskList);
             if (compileTimeConst != null) {
                 ValueParameterDescriptor valueParameterDescriptor =
                         DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(identifier, clazz);

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

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptorParent;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.data.ResolverNamespaceData;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor;
@@ -33,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
+import javax.inject.Inject;
 import java.util.Collections;
 import java.util.Map;
 
@@ -41,19 +43,33 @@ public final class NamespaceResolver {
     @NotNull
     public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptor(JavaDescriptorResolver.JAVA_ROOT);
     @NotNull
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    @NotNull
     private final Map<FqName, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
+    private PsiClassFinder psiClassFinder;
+    private BindingTrace trace;
+    private JavaSemanticServices javaSemanticServices;
 
-    public NamespaceResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) {
+    public NamespaceResolver() {
-        this.javaDescriptorResolver = javaDescriptorResolver;
+    }
+
+    @Inject
+    public void setPsiClassFinder(PsiClassFinder psiClassFinder) {
+        this.psiClassFinder = psiClassFinder;
+    }
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Inject
+    public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) {
+        this.javaSemanticServices = javaSemanticServices;
     }
 
     @Nullable
     public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         // First, let's check that there is no Kotlin package:
-        NamespaceDescriptor kotlinNamespaceDescriptor =
+        NamespaceDescriptor kotlinNamespaceDescriptor = javaSemanticServices.getKotlinNamespaceDescriptor(qualifiedName);
-                javaDescriptorResolver.getSemanticServices().getKotlinNamespaceDescriptor(qualifiedName);
         if (kotlinNamespaceDescriptor != null) {
             return searchRule.processFoundInKotlin(kotlinNamespaceDescriptor);
         }
@@ -79,7 +95,7 @@ public final class NamespaceResolver {
             return null;
         }
 
-        javaDescriptorResolver.getTrace().record(BindingContext.NAMESPACE, scopeData.getPsiPackageOrPsiClass(), ns);
+        trace.record(BindingContext.NAMESPACE, scopeData.getPsiPackageOrPsiClass(), ns);
 
         ns.setMemberScope(scopeData.getMemberScope());
 
@@ -112,15 +128,15 @@ public final class NamespaceResolver {
         lookingForPsi:
         {
             psiClass = getPsiClassForJavaPackageScope(fqName);
-            psiPackage = javaDescriptorResolver.getSemanticServices().getPsiClassFinder().findPsiPackage(fqName);
+            psiPackage = psiClassFinder.findPsiPackage(fqName);
             if (psiClass != null || psiPackage != null) {
-                javaDescriptorResolver.getTrace().record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.PROPER);
+                trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.PROPER);
                 break lookingForPsi;
             }
 
-            psiClass = javaDescriptorResolver.getPsiClassFinder().findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
+            psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
             if (psiClass != null && !psiClass.isEnum()) {
-                javaDescriptorResolver.getTrace().record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.CLASS_STATICS);
+                trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, ns, JavaNamespaceKind.CLASS_STATICS);
                 break lookingForPsi;
             }
 
@@ -135,7 +151,7 @@ public final class NamespaceResolver {
         ResolverNamespaceData namespaceData =
                 new ResolverNamespaceData(psiClass, psiPackage, fqName, ns);
 
-        namespaceData.setMemberScope(new JavaPackageScope(fqName, javaDescriptorResolver.getSemanticServices(), namespaceData));
+        namespaceData.setMemberScope(new JavaPackageScope(fqName, javaSemanticServices, namespaceData));
 
         ResolverNamespaceData oldValue =
                 namespaceDescriptorCacheByFqn.put(fqName, namespaceData);
@@ -169,7 +185,7 @@ public final class NamespaceResolver {
 
     @Nullable
     private PsiClass getPsiClassForJavaPackageScope(@NotNull FqName packageFQN) {
-        return javaDescriptorResolver.getPsiClassFinder()
+        return psiClassFinder.findPsiClass(packageFQN.child(Name.identifier(JvmAbi.PACKAGE_CLASS)),
-                .findPsiClass(packageFQN.child(Name.identifier(JvmAbi.PACKAGE_CLASS)), PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
+                                           PsiClassFinder.RuntimeClassesHandleMode.IGNORE);
     }
 }

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

@@ -40,10 +40,45 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 
+import javax.inject.Inject;
 import java.util.*;
 
 public final class PropertiesResolver {
 
+    private JavaSemanticServices semanticServices;
+    private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
+    private BindingTrace trace;
+    private JavaAnnotationResolver annotationResolver;
+    private ClassResolver classResolver;
+
+    public PropertiesResolver() {
+    }
+
+    @Inject
+    public void setSemanticServices(JavaSemanticServices semanticServices) {
+        this.semanticServices = semanticServices;
+    }
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Inject
+    public void setJavaDescriptorSignatureResolver(JavaDescriptorSignatureResolver javaDescriptorSignatureResolver) {
+        this.javaDescriptorSignatureResolver = javaDescriptorSignatureResolver;
+    }
+
+    @Inject
+    public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) {
+        this.annotationResolver = annotationResolver;
+    }
+
+    @Inject
+    public void setClassResolver(ClassResolver classResolver) {
+        this.classResolver = classResolver;
+    }
+
     public Set<VariableDescriptor> resolveFieldGroupByName(
             @NotNull Name fieldName,
             @NotNull ResolverScopeData scopeData
@@ -87,7 +122,6 @@ public final class PropertiesResolver {
 
         return descriptors;
     }
-
     private static class GroupingValue {
         PropertyAccessorData getter;
         PropertyAccessorData setter;
@@ -95,31 +129,6 @@ public final class PropertiesResolver {
         boolean ext;
     }
 
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    private JavaSemanticServices semanticServices;
-    private JavaDescriptorSignatureResolver javaDescriptorSignatureResolver;
-    private BindingTrace trace;
-
-    /* internal */
-    public PropertiesResolver(JavaDescriptorResolver resolver) {
-        this.javaDescriptorResolver = resolver;
-    }
-
-    /* internal */
-    public void setSemanticServices(JavaSemanticServices semanticServices) {
-        this.semanticServices = semanticServices;
-    }
-
-    /* internal */
-    public void setTrace(BindingTrace trace) {
-        this.trace = trace;
-    }
-
-    /* internal */
-    public void setJavaDescriptorSignatureResolver(JavaDescriptorSignatureResolver javaDescriptorSignatureResolver) {
-        this.javaDescriptorSignatureResolver = javaDescriptorSignatureResolver;
-    }
-
     private void resolveNamedGroupProperties(
             @NotNull ClassOrNamespaceDescriptor owner,
             @NotNull ResolverScopeData scopeData,
@@ -166,7 +175,7 @@ public final class PropertiesResolver {
             boolean isPropertyForNamedObject = members.field != null && JvmAbi.INSTANCE_FIELD.equals(members.field.getMember().getName());
             PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                     realOwner,
-                    javaDescriptorResolver.resolveAnnotations(characteristicMember.getMember().getPsiMember()),
+                    annotationResolver.resolveAnnotations(characteristicMember.getMember().getPsiMember()),
                     DescriptorResolverUtils
                             .resolveModality(characteristicMember.getMember(), isFinal || isEnumEntry || isPropertyForNamedObject),
                     visibility,
@@ -194,7 +203,7 @@ public final class PropertiesResolver {
             if (members.getter != null) {
                 getterDescriptor = new PropertyGetterDescriptor(
                         propertyDescriptor,
-                        javaDescriptorResolver.resolveAnnotations(members.getter.getMember().getPsiMember()),
+                        annotationResolver.resolveAnnotations(members.getter.getMember().getPsiMember()),
                         Modality.OPEN,
                         visibility,
                         true,
@@ -212,7 +221,7 @@ public final class PropertiesResolver {
                 }
                 setterDescriptor = new PropertySetterDescriptor(
                         propertyDescriptor,
-                        javaDescriptorResolver.resolveAnnotations(members.setter.getMember().getPsiMember()),
+                        annotationResolver.resolveAnnotations(members.setter.getMember().getPsiMember()),
                         Modality.OPEN,
                         setterVisibility,
                         true,
@@ -458,7 +467,7 @@ public final class PropertiesResolver {
         if (psiClass != null && psiClass.isEnum() && isStatic) {
             final String qualifiedName = psiClass.getQualifiedName();
             assert qualifiedName != null;
-            final ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName(qualifiedName));
+            final ClassDescriptor classDescriptor = classResolver.resolveClass(new FqName(qualifiedName));
             assert classDescriptor != null;
             final ClassDescriptor classObjectDescriptor = classDescriptor.getClassObjectDescriptor();
             assert classObjectDescriptor != null;

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

@@ -34,16 +34,16 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
+import javax.inject.Inject;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 public final class ValueParameterResolver {
 
-    private final JavaDescriptorResolver javaDescriptorResolver;
+    private JavaTypeTransformer typeTransformer;
 
-    public ValueParameterResolver(JavaDescriptorResolver javaDescriptorResolver) {
+    public ValueParameterResolver() {
-        this.javaDescriptorResolver = javaDescriptorResolver;
     }
 
     @NotNull
@@ -71,12 +71,11 @@ public final class ValueParameterResolver {
 
         JetType outType;
         if (typeFromAnnotation.length() > 0) {
-            outType = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
+            outType = getTypeTransformer().transformToType(typeFromAnnotation, typeVariableResolver);
-                    .transformToType(typeFromAnnotation, typeVariableResolver);
         }
         else {
-            outType = javaDescriptorResolver.getSemanticServices().getTypeTransformer()
+            outType = getTypeTransformer().transformToType(psiType, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT,
-                    .transformToType(psiType, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT, typeVariableResolver);
+                                                           typeVariableResolver);
         }
 
         JetType varargElementType;
@@ -115,6 +114,16 @@ public final class ValueParameterResolver {
         }
     }
 
+    @NotNull
+    private JavaTypeTransformer getTypeTransformer() {
+        return typeTransformer;
+    }
+
+    @Inject
+    public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
+    }
+
     @NotNull
     private static String getParameterName(int number, @NotNull PsiParameterWrapper parameter) {
         String psiParameterName = parameter.getPsiParameter().getName();