use dependency injector for JavaDescriptorResolver

JavaDescriptorResolver now lives in the same context as TopDownAnalyzer

compiler/frontend.java/frontend.java.iml

@@ -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>
 

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

@@ -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;
+    }
+
+}

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

@@ -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;
+    }
+
+}

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

@@ -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,
+        final ModuleDescriptor owner = new ModuleDescriptor("<module>");
-                JavaBridgeConfiguration.createJavaBridgeConfiguration(project, bindingTraceContext, DefaultModuleConfiguration.createStandardConfiguration(project)),
+
-                files,
+        TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
-                filesToAnalyzeCompletely,
+                filesToAnalyzeCompletely, false, false, bindingTraceContext);
-                flowDataTraceFactory,
+
-                bindingTraceContext
+
-        );
+        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
+                project, topDownAnalysisParameters, owner, flowDataTraceFactory, bindingTraceContext);
+
+
+        injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files);
         return bindingTraceContext.getBindingContext();
     }
 

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

@@ -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;
+    @NotNull
-    private final JavaSemanticServices javaSemanticServices;
+    private Project project;
-    private final ModuleConfiguration delegateConfiguration;
+    @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 = DefaultModuleConfiguration.createStandardConfiguration(project);
-        this.delegateConfiguration = delegateConfiguration;
     }
 
+    @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) {

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

@@ -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 JavaPsiFacade javaFacade;
-    protected final GlobalSearchScope javaSearchScope;
+    protected Project project;
-    protected final JavaSemanticServices semanticServices;
+    protected GlobalSearchScope javaSearchScope ;
-    private final AltClassFinder altClassFinder;
+    protected JavaSemanticServices semanticServices;
+    private AltClassFinder altClassFinder;
 
-    public JavaDescriptorResolver(Project project, JavaSemanticServices semanticServices) {
+    @Inject
-        this.javaFacade = JavaPsiFacade.getInstance(project);
+    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;
+        this.javaFacade = JavaPsiFacade.getInstance(project);
-        altClassFinder = new AltClassFinder(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());

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

@@ -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;
+    @NotNull
-    private final JavaDescriptorResolver descriptorResolver;
+    private JavaTypeTransformer typeTransformer;
-    private final BindingTrace trace;
+    @NotNull
+    private JavaDescriptorResolver descriptorResolver;
+    @NotNull
+    private BindingTrace trace;
 
-    public JavaSemanticServices(Project project, BindingTrace trace) {
+
-        this.trace = trace;
+    @Inject
-        this.descriptorResolver = new JavaDescriptorResolver(project, this);
+    public void setTypeTransformer(@NotNull JavaTypeTransformer typeTransformer) {
-        this.typeTransformer = new JavaTypeTransformer(this, JetStandardLibrary.getInstance(), descriptorResolver);
+        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;

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

@@ -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 JavaSemanticServices javaSemanticServices;
-    private final JavaDescriptorResolver resolver;
+    private JavaDescriptorResolver resolver;
-    private final JetStandardLibrary standardLibrary;
+
+    @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(), JetStandardLibrary.getInstance().getPrimitiveJetType(primitiveType));
-                primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), standardLibrary.getPrimitiveArrayJetType(primitiveType));
+                primitiveTypesMap.put("[" + jvmPrimitiveType.getName(), JetStandardLibrary.getInstance().getPrimitiveArrayJetType(primitiveType));
-                primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName(), standardLibrary.getNullablePrimitiveJetType(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.String", JetStandardLibrary.getInstance().getNullableStringType());
-            classTypesMap.put("java.lang.CharSequence", standardLibrary.getNullableCharSequenceType());
+            classTypesMap.put("java.lang.CharSequence", JetStandardLibrary.getInstance().getNullableCharSequenceType());
-            classTypesMap.put("java.lang.Throwable", standardLibrary.getNullableThrowableType());
+            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.String", JetStandardLibrary.getInstance().getString());
-            classDescriptorMap.put("java.lang.CharSequence", standardLibrary.getCharSequence());
+            classDescriptorMap.put("java.lang.CharSequence", JetStandardLibrary.getInstance().getCharSequence());
-            classDescriptorMap.put("java.lang.Throwable", standardLibrary.getThrowable());
+            classDescriptorMap.put("java.lang.Throwable", JetStandardLibrary.getInstance().getThrowable());
         }
         return classDescriptorMap;
     }

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

@@ -25,9 +25,9 @@ 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.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -42,13 +42,13 @@ import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
-import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.annotations.NotNull;
 
 /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */
-public class InjectorForTopDownAnalyzer {
+public class InjectorForTopDownAnalyzerBasic {
 
     private TopDownAnalyzer topDownAnalyzer;
     private TopDownAnalysisContext topDownAnalysisContext;
@@ -59,12 +59,12 @@ public class InjectorForTopDownAnalyzer {
     private final Project project;
     private final TopDownAnalysisParameters topDownAnalysisParameters;
 
-    public InjectorForTopDownAnalyzer(
+    public InjectorForTopDownAnalyzerBasic(
         @NotNull Project project,
         @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
-        @NotNull ModuleConfiguration moduleConfiguration,
         @NotNull ModuleDescriptor moduleDescriptor,
-        JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory
+        JetControlFlowDataTraceFactory jetControlFlowDataTraceFactory,
+        @NotNull ModuleConfiguration moduleConfiguration
     ) {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.topDownAnalysisContext = new TopDownAnalysisContext();

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

@@ -16,17 +16,11 @@
 
 package org.jetbrains.jet.lang.resolve;
 
-import com.google.common.base.Predicate;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
-import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
-import org.jetbrains.jet.lang.ModuleConfiguration;
-import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;

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

@@ -18,12 +18,11 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
-import com.google.common.collect.Lists;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
+import org.jetbrains.jet.di.InjectorForTopDownAnalyzerBasic;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -31,11 +30,9 @@ import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.JetScopeAdapter;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
-import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
@@ -155,7 +152,7 @@ public class TopDownAnalyzer {
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(analyzeCompletely, false, declaredLocally, trace);
 
-        InjectorForTopDownAnalyzer injector = new InjectorForTopDownAnalyzer(project, topDownAnalysisParameters, configuration, moduleDescriptor, flowDataTraceFactory);
+        InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(project, topDownAnalysisParameters, moduleDescriptor, flowDataTraceFactory, configuration);
 
         injector.getTopDownAnalyzer().doProcess(outerScope, owner, declarations);
 
@@ -208,9 +205,9 @@ public class TopDownAnalyzer {
             @NotNull List<JetFile> files) {
 
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(Predicates.<PsiFile>alwaysFalse(), true, false, trace);
-        InjectorForTopDownAnalyzer injector = new InjectorForTopDownAnalyzer(
+        InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
-                project, topDownAnalysisParameters, ModuleConfiguration.EMPTY,
+                project, topDownAnalysisParameters,
-                JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, null);
+                JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, null,  ModuleConfiguration.EMPTY);
 
         injector.getTopDownAnalyzer().doProcessStandardLibraryNamespace(outerScope, standardLibraryNamespace, files);
     }
@@ -279,14 +276,14 @@ public class TopDownAnalyzer {
         TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters(
                 filesToAnalyzeCompletely, false, false, bindingTraceContext);
 
-        InjectorForTopDownAnalyzer injector = new InjectorForTopDownAnalyzer(
+        InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
-                project, topDownAnalysisParameters, configuration, owner, flowDataTraceFactory);
+                project, topDownAnalysisParameters, owner, flowDataTraceFactory, configuration);
 
 
         injector.getTopDownAnalyzer().doAnalyzeFilesWithGivenTrance2(files);
     }
 
-    private void doAnalyzeFilesWithGivenTrance2(Collection<JetFile> files) {
+    public void doAnalyzeFilesWithGivenTrance2(Collection<JetFile> files) {
         final WritableScope scope = new WritableScopeImpl(
                 JetScope.EMPTY, moduleDescriptor,
                 new TraceBasedRedeclarationHandler(topDownAnalysisParameters.getTrace())).setDebugName("Root scope in analyzeNamespace");

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestForever.java

@@ -0,0 +1,69 @@
+/*
+ * 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.checkers;
+
+import junit.textui.ResultPrinter;
+import junit.textui.TestRunner;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class JetDiagnosticsTestForever {
+    public static void main(String[] args) {
+        TestRunner.run(JetDiagnosticsTest.suite());
+        TestRunner.run(JetDiagnosticsTest.suite());
+        
+        int limit = args.length > 0 ? Integer.parseInt(args[0]) : Integer.MAX_VALUE;
+
+        long total = 0;
+        long min = Long.MAX_VALUE;
+        long[] last100 = new long[100];
+        long[] last10 = new long[10];
+        for (int i = -100; i < limit; ++i) {
+            TestRunner runner = new TestRunner();
+            runner.setPrinter(new ResultPrinter(new PrintStream(new ByteArrayOutputStream())));
+            long start = System.nanoTime();
+            runner.doRun(JetDiagnosticsTest.suite());
+            long d = System.nanoTime() - start;
+            last100[(i + 100) % 100] = d;
+            last10[(i + 100) % 10] = d;
+            long dMs = d / 1000 / 1000;
+            if (i >= 1) {
+                total += d;
+                min = Math.min(min, d);
+                long avg = total / i / 1000 / 1000;
+                long avg10 = avg(last10) / 1000 / 1000;
+                long avg100 = avg(last100) / 1000 / 1000;
+                long minMs = min / 1000 / 1000;
+                System.out.println(dMs + "ms; avg=" + avg + "ms; avg10=" + avg10 + "ms; avg100=" + avg100 + "ms; min=" + minMs + "ms; iteration=" + i);
+            } else {
+                System.out.println(dMs + "ms; iteration=" + i);
+            }
+        }
+    }
+    
+    private static long avg(long[] array) {
+        long sum = 0;
+        for (long l : array) {
+            sum += l;
+        }
+        return sum / array.length;
+    }
+}

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

@@ -25,6 +25,7 @@ import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -113,9 +114,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
         jetCoreEnvironment.addToClasspath(tmpdir);
         jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
 
-        JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext());
+        JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()).getJavaDescriptorResolver();
-
-        JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
         return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
     }
 

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

@@ -29,15 +29,14 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.codegen.ClassBuilderFactories;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 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.FqName;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.junit.Assert;
 
@@ -91,9 +90,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
         jetCoreEnvironment.addToClasspath(tmpdir);
         jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
 
-        JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext());
+        JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()).getJavaDescriptorResolver();
-
-        JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
         NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
         
         NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, false, txtFile);

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

@@ -25,18 +25,18 @@ import com.intellij.psi.PsiMethod;
 import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestCaseBuilder;
+import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeProjection;
@@ -123,8 +123,8 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
     @NotNull
     private PsiClass findClass(String qualifiedName) {
         Project project = getProject();
-        JavaSemanticServices javaSemanticServices = new JavaSemanticServices(project, new BindingTraceContext());
+        JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(project).getJavaDescriptorResolver();
-        return javaSemanticServices.getDescriptorResolver().findClass(new FqName(qualifiedName));
+        return javaDescriptorResolver.findClass(new FqName(qualifiedName));
     }
 
     @NotNull

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

@@ -23,6 +23,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -584,9 +585,11 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     private WritableScopeImpl addImports(JetScope scope) {
         WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING);
         writableScope.importScope(library.getLibraryScope());
-        JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), JetTestUtils.DUMMY_TRACE);
+        JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(getProject()).getJavaDescriptorResolver();
-        writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope());
+        writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT,
-        writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope());
+                DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope());
+        writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"),
+                DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
         return writableScope;
     }

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

@@ -26,11 +26,11 @@ import com.intellij.psi.util.PsiTreeUtil;
 import jet.runtime.typeinfo.JetClass;
 import jet.runtime.typeinfo.JetMethod;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
@@ -60,9 +60,9 @@ class DecompiledDataFactory {
     private DecompiledDataFactory(ClsFileImpl clsFile) {
         myClsFile = clsFile;
         Project project = myClsFile.getProject();
-        JavaSemanticServices jss = new JavaSemanticServices(project, new BindingTraceContext());
+        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project);
-        myBindingContext = jss.getTrace().getBindingContext();
+        myBindingContext = injector.getBindingTrace().getBindingContext();
-        myJavaDescriptorResolver = jss.getDescriptorResolver();
+        myJavaDescriptorResolver = injector.getJavaDescriptorResolver();
     }
 
     @NotNull

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

@@ -22,6 +22,9 @@ import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
 
@@ -35,14 +38,29 @@ import java.io.IOException;
 public class AllInjectorsGenerator {
 
     public static void main(String[] args) throws IOException {
-        generateProductionInjector();
+        generateInjectorForTopDownAnalyzerBasic();
+        generateInjectorForTopDownAnalyzerForJvm();
         generateMacroInjector();
         generateTestInjector();
+        generateInjectorForJavaSemanticServices();
     }
 
-    private static void generateProductionInjector() throws IOException {
+    private static void generateInjectorForTopDownAnalyzerBasic() throws IOException {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
+        generateInjectorForTopDownAnalyzerCommon(generator);
+        generator.addParameter(ModuleConfiguration.class);
+        generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic");
+    }
 
+    private static void generateInjectorForTopDownAnalyzerForJvm() throws IOException {
+        DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
+        generateInjectorForTopDownAnalyzerCommon(generator);
+        generator.addPublicField(JavaBridgeConfiguration.class);
+        generator.addPublicParameter(BindingTrace.class);
+        generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm");
+    }
+
+    private static void generateInjectorForTopDownAnalyzerCommon(DependencyInjectorGenerator generator) {
         // Fields
         generator.addPublicField(TopDownAnalyzer.class);
         generator.addPublicField(TopDownAnalysisContext.class);
@@ -54,11 +72,8 @@ public class AllInjectorsGenerator {
         // Parameters
         generator.addPublicParameter(Project.class);
         generator.addPublicParameter(TopDownAnalysisParameters.class);
-        generator.addParameter(ModuleConfiguration.class);
         generator.addParameter(ModuleDescriptor.class);
         generator.addParameter(JetControlFlowDataTraceFactory.class, false);
-
-        generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzer");
     }
 
     private static void generateMacroInjector() throws IOException {
@@ -88,5 +103,19 @@ public class AllInjectorsGenerator {
 
         generator.generate("compiler/tests", "org.jetbrains.jet.di", "InjectorForTests");
     }
+    
+    private static void generateInjectorForJavaSemanticServices() throws IOException {
+        DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
+        
+        // Fields
+        generator.addPublicField(JavaSemanticServices.class);
+        generator.addPublicField(JavaDescriptorResolver.class);
+        generator.addField(true, BindingTrace.class, null, new GivenExpression("new org.jetbrains.jet.lang.resolve.BindingTraceContext()"));
+        
+        // Parameters
+        generator.addPublicParameter(Project.class);
+        
+        generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForJavaSemanticServices");
+    }
 
 }

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

@@ -329,7 +329,13 @@ public class DependencyInjectorGenerator {
     }
 
     private Field findDependencyOfType(Class<?> parameterType, String errorMessage, Field neededFor) {
-        Collection<Field> fields = typeToField.get(parameterType);
+        List<Field> fields = Lists.newArrayList();
+        for (Map.Entry<Class<?>, Field> entry : typeToField.entries()) {
+            if (parameterType.isAssignableFrom(entry.getKey())) {
+                fields.add(entry.getValue());
+            }
+        }
+        
         Field dependency;
         if (fields.isEmpty()) {
             dependency = addField(parameterType);