use dependency injector for JavaDescriptorResolver

JavaDescriptorResolver now lives in the same context as TopDownAnalyzer
2012-03-22 03:47:05 +04:00
parent bb7b8007c2
commit 162525f794
19 changed files with 550 additions and 104 deletions
@@ -11,6 +11,7 @@
    <orderEntry type="library" scope="PROVIDED" name="intellij-core" level="project" />
    <orderEntry type="module" module-name="util" exported="" />
    <orderEntry type="module" module-name="runtime" />
+    <orderEntry type="library" name="javax.inject" level="project" />
  </component>
 </module>

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2010-2012 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 com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+
+/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */
+public class InjectorForJavaSemanticServices {
+
+    private JavaSemanticServices javaSemanticServices;
+    private JavaDescriptorResolver javaDescriptorResolver;
+    private BindingTrace bindingTrace;
+    private final Project project;
+
+    public InjectorForJavaSemanticServices(
+        @NotNull Project project
+    ) {
+        this.javaSemanticServices = new JavaSemanticServices();
+        this.javaDescriptorResolver = new JavaDescriptorResolver();
+        this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext();
+        this.project = project;
+        JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer();
+
+        this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
+        this.javaSemanticServices.setTrace(bindingTrace);
+        this.javaSemanticServices.setTypeTransformer(javaTypeTransformer);
+
+        this.javaDescriptorResolver.setProject(project);
+        this.javaDescriptorResolver.setSemanticServices(javaSemanticServices);
+
+        javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
+        javaTypeTransformer.setResolver(javaDescriptorResolver);
+
+    }
+
+    public JavaSemanticServices getJavaSemanticServices() {
+        return this.javaSemanticServices;
+    }
+
+    public JavaDescriptorResolver getJavaDescriptorResolver() {
+        return this.javaDescriptorResolver;
+    }
+
+    public BindingTrace getBindingTrace() {
+        return this.bindingTrace;
+    }
+
+    public Project getProject() {
+        return this.project;
+    }
+
+}
@@ -0,0 +1,228 @@
+/*
+ * Copyright 2010-2012 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.TopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.TopDownAnalysisContext;
+import org.jetbrains.jet.lang.resolve.BodyResolver;
+import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
+import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.DeclarationResolver;
+import org.jetbrains.jet.lang.resolve.AnnotationResolver;
+import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
+import org.jetbrains.jet.lang.resolve.TypeResolver;
+import org.jetbrains.jet.lang.resolve.calls.OverloadingConflictResolver;
+import org.jetbrains.jet.lang.resolve.ImportsResolver;
+import org.jetbrains.jet.lang.resolve.DelegationResolver;
+import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
+import org.jetbrains.jet.lang.resolve.OverloadResolver;
+import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer;
+import com.intellij.openapi.project.Project;
+import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.annotations.NotNull;
+
+/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */
+public class InjectorForTopDownAnalyzerForJvm {
+
+    private TopDownAnalyzer topDownAnalyzer;
+    private TopDownAnalysisContext topDownAnalysisContext;
+    private BodyResolver bodyResolver;
+    private ControlFlowAnalyzer controlFlowAnalyzer;
+    private DeclarationsChecker declarationsChecker;
+    private DescriptorResolver descriptorResolver;
+    private final Project project;
+    private final TopDownAnalysisParameters topDownAnalysisParameters;
+    private JavaBridgeConfiguration javaBridgeConfiguration;
+    private final BindingTrace bindingTrace;
+
+    public InjectorForTopDownAnalyzerForJvm(
+        @NotNull Project project,
+        @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
+        @NotNull ModuleDescriptor moduleDescriptor,
+        JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory,
+        @NotNull BindingTrace bindingTrace
+    ) {
+        this.topDownAnalyzer = new TopDownAnalyzer();
+        this.topDownAnalysisContext = new TopDownAnalysisContext();
+        this.bodyResolver = new BodyResolver();
+        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
+        this.declarationsChecker = new DeclarationsChecker();
+        this.descriptorResolver = new DescriptorResolver();
+        this.project = project;
+        this.topDownAnalysisParameters = topDownAnalysisParameters;
+        this.javaBridgeConfiguration = new JavaBridgeConfiguration();
+        this.bindingTrace = bindingTrace;
+        DeclarationResolver declarationResolver = new DeclarationResolver();
+        AnnotationResolver annotationResolver = new AnnotationResolver();
+        CallResolver callResolver = new CallResolver();
+        ExpressionTypingServices expressionTypingServices = new ExpressionTypingServices();
+        TypeResolver typeResolver = new TypeResolver();
+        OverloadingConflictResolver overloadingConflictResolver = new OverloadingConflictResolver();
+        ImportsResolver importsResolver = new ImportsResolver();
+        DelegationResolver delegationResolver = new DelegationResolver();
+        NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl();
+        OverloadResolver overloadResolver = new OverloadResolver();
+        OverrideResolver overrideResolver = new OverrideResolver();
+        TypeHierarchyResolver typeHierarchyResolver = new TypeHierarchyResolver();
+        JavaSemanticServices javaSemanticServices = new JavaSemanticServices();
+        JavaDescriptorResolver javaDescriptorResolver = new JavaDescriptorResolver();
+        JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer();
+
+        this.topDownAnalyzer.setBodyResolver(bodyResolver);
+        this.topDownAnalyzer.setConfiguration(javaBridgeConfiguration);
+        this.topDownAnalyzer.setContext(topDownAnalysisContext);
+        this.topDownAnalyzer.setControlFlowAnalyzer(controlFlowAnalyzer);
+        this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
+        this.topDownAnalyzer.setDeclarationsChecker(declarationsChecker);
+        this.topDownAnalyzer.setDelegationResolver(delegationResolver);
+        this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor);
+        this.topDownAnalyzer.setNamespaceFactory(namespaceFactoryImpl);
+        this.topDownAnalyzer.setOverloadResolver(overloadResolver);
+        this.topDownAnalyzer.setOverrideResolver(overrideResolver);
+        this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
+        this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver);
+
+        this.topDownAnalysisContext.setTopDownAnalysisParameters(topDownAnalysisParameters);
+
+        this.bodyResolver.setCallResolver(callResolver);
+        this.bodyResolver.setContext(topDownAnalysisContext);
+        this.bodyResolver.setDescriptorResolver(descriptorResolver);
+        this.bodyResolver.setExpressionTypingServices(expressionTypingServices);
+        this.bodyResolver.setTopDownAnalysisParameters(topDownAnalysisParameters);
+
+        this.controlFlowAnalyzer.setContext(topDownAnalysisContext);
+        this.controlFlowAnalyzer.setFlowDataTraceFactory(jetControlFlowDataTraceFactory);
+        this.controlFlowAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters);
+
+        this.declarationsChecker.setContext(topDownAnalysisContext);
+
+        this.descriptorResolver.setAnnotationResolver(annotationResolver);
+        this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        this.descriptorResolver.setTypeResolver(typeResolver);
+
+        this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices);
+        this.javaBridgeConfiguration.setProject(project);
+
+        declarationResolver.setAnnotationResolver(annotationResolver);
+        declarationResolver.setContext(topDownAnalysisContext);
+        declarationResolver.setDescriptorResolver(descriptorResolver);
+        declarationResolver.setImportsResolver(importsResolver);
+
+        annotationResolver.setCallResolver(callResolver);
+        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+
+        callResolver.setDescriptorResolver(descriptorResolver);
+        callResolver.setExpressionTypingServices(expressionTypingServices);
+        callResolver.setOverloadingConflictResolver(overloadingConflictResolver);
+        callResolver.setTypeResolver(typeResolver);
+
+        expressionTypingServices.setCallResolver(callResolver);
+        expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setProject(project);
+        expressionTypingServices.setTypeResolver(typeResolver);
+
+        typeResolver.setAnnotationResolver(annotationResolver);
+        typeResolver.setDescriptorResolver(descriptorResolver);
+
+        importsResolver.setConfiguration(javaBridgeConfiguration);
+        importsResolver.setContext(topDownAnalysisContext);
+
+        delegationResolver.setContext(topDownAnalysisContext);
+
+        namespaceFactoryImpl.setConfiguration(javaBridgeConfiguration);
+        namespaceFactoryImpl.setContext(topDownAnalysisContext);
+        namespaceFactoryImpl.setModuleDescriptor(moduleDescriptor);
+
+        overloadResolver.setContext(topDownAnalysisContext);
+
+        overrideResolver.setContext(topDownAnalysisContext);
+        overrideResolver.setTopDownAnalysisParameters(topDownAnalysisParameters);
+
+        typeHierarchyResolver.setContext(topDownAnalysisContext);
+        typeHierarchyResolver.setDescriptorResolver(descriptorResolver);
+        typeHierarchyResolver.setImportsResolver(importsResolver);
+        typeHierarchyResolver.setNamespaceFactory(namespaceFactoryImpl);
+
+        javaSemanticServices.setDescriptorResolver(javaDescriptorResolver);
+        javaSemanticServices.setTrace(bindingTrace);
+        javaSemanticServices.setTypeTransformer(javaTypeTransformer);
+
+        javaDescriptorResolver.setProject(project);
+        javaDescriptorResolver.setSemanticServices(javaSemanticServices);
+
+        javaTypeTransformer.setJavaSemanticServices(javaSemanticServices);
+        javaTypeTransformer.setResolver(javaDescriptorResolver);
+
+    }
+
+    public TopDownAnalyzer getTopDownAnalyzer() {
+        return this.topDownAnalyzer;
+    }
+
+    public TopDownAnalysisContext getTopDownAnalysisContext() {
+        return this.topDownAnalysisContext;
+    }
+
+    public BodyResolver getBodyResolver() {
+        return this.bodyResolver;
+    }
+
+    public ControlFlowAnalyzer getControlFlowAnalyzer() {
+        return this.controlFlowAnalyzer;
+    }
+
+    public DeclarationsChecker getDeclarationsChecker() {
+        return this.declarationsChecker;
+    }
+
+    public DescriptorResolver getDescriptorResolver() {
+        return this.descriptorResolver;
+    }
+
+    public Project getProject() {
+        return this.project;
+    }
+
+    public TopDownAnalysisParameters getTopDownAnalysisParameters() {
+        return this.topDownAnalysisParameters;
+    }
+
+    public JavaBridgeConfiguration getJavaBridgeConfiguration() {
+        return this.javaBridgeConfiguration;
+    }
+
+    public BindingTrace getBindingTrace() {
+        return this.bindingTrace;
+    }
+
+}
@@ -29,14 +29,15 @@ import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.DefaultModuleConfiguration;
+import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;

 import java.util.Collection;
 import java.util.Collections;
@@ -145,14 +146,18 @@ public class AnalyzerFacadeForJVM {
    public static BindingContext analyzeFilesWithJavaIntegration(Project project, Collection<JetFile> files, Predicate<PsiFile> filesToAnalyzeCompletely,
                                                                 JetControlFlowDataTraceFactory flowDataTraceFactory) {
        BindingTraceContext bindingTraceContext = new BindingTraceContext();
-        AnalyzingUtils.analyzeFilesWithGivenTrace(
-                project,
-                JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext, DefaultModuleConfiguration.createStandardConfiguration(project)),
-                files,
-                filesToAnalyzeCompletely,
-                flowDataTraceFactory,
-                bindingTraceContext
-        );
+
+        final ModuleDescriptor owner = new ModuleDescriptor("<module>");
+
+        TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
+                filesToAnalyzeCompletely, false, false, bindingTraceContext);
+
+
+        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
+                project, topDownAnalysisParameters, owner, flowDataTraceFactory, bindingTraceContext);
+
+
+        injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files);
        return bindingTraceContext.getBindingContext();
    }

@@ -18,6 +18,7 @@ package org.jetbrains.jet.lang.resolve.java;

 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -29,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;

+import javax.inject.Inject;
 import java.util.Collection;
 import java.util.Collections;

@@ -39,20 +41,27 @@ public class JavaBridgeConfiguration implements ModuleConfiguration {

    public static final ImportPath[] DEFAULT_JAVA_IMPORTS = new ImportPath[] { new ImportPath("java.lang.*") };

-    public static ModuleConfiguration createJavaBridgeConfiguration(@NotNull Project project, @NotNull BindingTrace trace, ModuleConfiguration delegateConfiguration) {
-        return new JavaBridgeConfiguration(project, trace, delegateConfiguration);
-    }

-    private final Project project;
-    private final JavaSemanticServices javaSemanticServices;
-    private final ModuleConfiguration delegateConfiguration;
+    @NotNull
+    private Project project;
+    @NotNull
+    private JavaSemanticServices javaSemanticServices;
+    @NotNull
+    private ModuleConfiguration delegateConfiguration;

-    private JavaBridgeConfiguration(Project project, BindingTrace trace, ModuleConfiguration delegateConfiguration) {
+    @Inject
+    public void setProject(@NotNull Project project) {
        this.project = project;
-        this.javaSemanticServices = new JavaSemanticServices(project, trace);
-        this.delegateConfiguration = delegateConfiguration;
+        this.delegateConfiguration = DefaultModuleConfiguration.createStandardConfiguration(project);
    }

+    @Inject
+    public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) {
+        this.javaSemanticServices = javaSemanticServices;
+    }
+
+
+
    @Override
    public void addDefaultImports(@NotNull WritableScope rootScope, @NotNull Collection<JetImportDirective> directives) {
        for (ImportPath importPath : DEFAULT_JAVA_IMPORTS) {
@@ -48,6 +48,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.*;

 /**
@@ -193,23 +194,32 @@ public class JavaDescriptorResolver {
    protected final Map<FqName, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
    protected final Map<PsiElement, ResolverNamespaceData> namespaceDescriptorCache = Maps.newHashMap();

-    protected final JavaPsiFacade javaFacade;
-    protected final GlobalSearchScope javaSearchScope;
-    protected final JavaSemanticServices semanticServices;
-    private final AltClassFinder altClassFinder;
+    protected JavaPsiFacade javaFacade;
+    protected Project project;
+    protected GlobalSearchScope javaSearchScope ;
+    protected JavaSemanticServices semanticServices;
+    private AltClassFinder altClassFinder;

-    public JavaDescriptorResolver(Project project, JavaSemanticServices semanticServices) {
-        this.javaFacade = JavaPsiFacade.getInstance(project);
+    @Inject
+    public void setProject(Project project) {
+        this.project = project;
+        this.altClassFinder = new AltClassFinder(project);
        this.javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) {
            @Override
            public boolean contains(VirtualFile file) {
                return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE;
            }
        };
-        this.semanticServices = semanticServices;
-        altClassFinder = new AltClassFinder(project);
+        this.javaFacade = JavaPsiFacade.getInstance(project);
    }
-    
+
+    @Inject
+    public void setSemanticServices(JavaSemanticServices semanticServices) {
+        this.semanticServices = semanticServices;
+    }
+
+
+
    @Nullable
    ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) {
        FqName qualifiedName = new FqName(psiClass.getQualifiedName());
@@ -26,20 +26,37 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;

+import javax.inject.Inject;
+
 /**
 * @author abreslav
 */
 public class JavaSemanticServices {
-    private final JavaTypeTransformer typeTransformer;
-    private final JavaDescriptorResolver descriptorResolver;
-    private final BindingTrace trace;
+    @NotNull
+    private JavaTypeTransformer typeTransformer;
+    @NotNull
+    private JavaDescriptorResolver descriptorResolver;
+    @NotNull
+    private BindingTrace trace;

-    public JavaSemanticServices(Project project, BindingTrace trace) {
-        this.trace = trace;
-        this.descriptorResolver = new JavaDescriptorResolver(project, this);
-        this.typeTransformer = new JavaTypeTransformer(this, JetStandardLibrary.getInstance(), descriptorResolver);
+
+    @Inject
+    public void setTypeTransformer(@NotNull JavaTypeTransformer typeTransformer) {
+        this.typeTransformer = typeTransformer;
    }

+    @Inject
+    public void setDescriptorResolver(@NotNull JavaDescriptorResolver descriptorResolver) {
+        this.descriptorResolver = descriptorResolver;
+    }
+
+    @Inject
+    public void setTrace(@NotNull BindingTrace trace) {
+        this.trace = trace;
+    }
+
+
+
    @NotNull
    public JavaTypeTransformer getTypeTransformer() {
        return typeTransformer;
@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.lang.PrimitiveType;
 import org.jetbrains.jet.rt.signature.JetSignatureReader;

+import javax.inject.Inject;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -38,18 +39,26 @@ import java.util.Map;
 */
 public class JavaTypeTransformer {

-    private final JavaSemanticServices javaSemanticServices;
-    private final JavaDescriptorResolver resolver;
-    private final JetStandardLibrary standardLibrary;
+    private JavaSemanticServices javaSemanticServices;
+    private JavaDescriptorResolver resolver;
+
+    @Inject
+    public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) {
+        this.javaSemanticServices = javaSemanticServices;
+    }
+
+    @Inject
+    public void setResolver(JavaDescriptorResolver resolver) {
+        this.resolver = resolver;
+    }
+
+
+
    private Map<String, JetType> primitiveTypesMap;
    private Map<String, JetType> classTypesMap;
    private Map<String, ClassDescriptor> classDescriptorMap;

-    public JavaTypeTransformer(JavaSemanticServices javaSemanticServices, JetStandardLibrary standardLibrary, JavaDescriptorResolver resolver) {
-        this.javaSemanticServices = javaSemanticServices;
-        this.resolver = resolver;
-        this.standardLibrary = standardLibrary;
-    }
+

    @NotNull
    public TypeProjection transformToTypeProjection(@NotNull final PsiType javaType,
@@ -85,7 +94,7 @@ public class JavaTypeTransformer {
    @NotNull
    public JetType transformToType(@NotNull String kotlinSignature, TypeVariableResolver typeVariableResolver) {
        final JetType[] r = new JetType[1];
-        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, standardLibrary, typeVariableResolver) {
+        JetTypeJetSignatureReader reader = new JetTypeJetSignatureReader(javaSemanticServices, JetStandardLibrary.getInstance(), typeVariableResolver) {
            @Override
            protected void done(@NotNull JetType jetType) {
                r[0] = jetType;
@@ -173,7 +182,7 @@ public class JavaTypeTransformer {
                }

                JetType type = transformToType(componentType, typeVariableResolver);
-                return TypeUtils.makeNullable(standardLibrary.getArrayType(type));
+                return TypeUtils.makeNullable(JetStandardLibrary.getInstance().getArrayType(type));
            }

            @Override
@@ -188,9 +197,9 @@ public class JavaTypeTransformer {
            primitiveTypesMap = new HashMap<String, JetType>();
            for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
                PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
-                primitiveTypesMap.put(jvmPrimitiveType.getName(), standardLibrary.getPrimitiveJetType(primitiveType));
-                primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), standardLibrary.getPrimitiveArrayJetType(primitiveType));
-                primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(primitiveType));
+                primitiveTypesMap.put(jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveJetType(primitiveType));
+                primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveArrayJetType(primitiveType));
+                primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType(primitiveType));
            }
            primitiveTypesMap.put("void", JetStandardClasses.getUnitType());
        }
@@ -202,12 +211,12 @@ public class JavaTypeTransformer {
            classTypesMap = new HashMap<String, JetType>();
            for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
                PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
-                classTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(primitiveType));
+                classTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType(primitiveType));
            }
            classTypesMap.put("java.lang.Object", JetStandardClasses.getNullableAnyType());
-            classTypesMap.put("java.lang.String", standardLibrary.getNullableStringType());
-            classTypesMap.put("java.lang.CharSequence", standardLibrary.getNullableCharSequenceType());
-            classTypesMap.put("java.lang.Throwable", standardLibrary.getNullableThrowableType());
+            classTypesMap.put("java.lang.String", JetStandardLibrary.getInstance().getNullableStringType());
+            classTypesMap.put("java.lang.CharSequence", JetStandardLibrary.getInstance().getNullableCharSequenceType());
+            classTypesMap.put("java.lang.Throwable", JetStandardLibrary.getInstance().getNullableThrowableType());
        }
        return classTypesMap;
    }
@@ -217,11 +226,11 @@ public class JavaTypeTransformer {
            classDescriptorMap = new HashMap<String, ClassDescriptor>();
            for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) {
                PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType();
-                classDescriptorMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getPrimitiveClassDescriptor(primitiveType));
+                classDescriptorMap.put(jvmPrimitiveType.getWrapper().getFqName(), JetStandardLibrary.getInstance().getPrimitiveClassDescriptor(primitiveType));
            }
-            classDescriptorMap.put("java.lang.String", standardLibrary.getString());
-            classDescriptorMap.put("java.lang.CharSequence", standardLibrary.getCharSequence());
-            classDescriptorMap.put("java.lang.Throwable", standardLibrary.getThrowable());
+            classDescriptorMap.put("java.lang.String", JetStandardLibrary.getInstance().getString());
+            classDescriptorMap.put("java.lang.CharSequence", JetStandardLibrary.getInstance().getCharSequence());
+            classDescriptorMap.put("java.lang.Throwable", JetStandardLibrary.getInstance().getThrowable());
        }
        return classDescriptorMap;
    }