Common injector for lazy resolve with java lazy resolve

2014-02-05 15:08:26 +04:00
parent 2ef879ea3e
commit a2c567da93
6 changed files with 275 additions and 59 deletions
@@ -0,0 +1,219 @@
+/*
+ * Copyright 2010-2014 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 com.intellij.openapi.project.Project;
+import org.jetbrains.jet.context.GlobalContextImpl;
+import org.jetbrains.jet.storage.LockBasedStorageManager;
+import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl;
+import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder;
+import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
+import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.LazyResolveBasedCache;
+import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter;
+import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
+import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
+import org.jetbrains.jet.lang.resolve.AnnotationResolver;
+import org.jetbrains.jet.lang.resolve.calls.CallResolver;
+import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
+import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
+import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver;
+import org.jetbrains.jet.lang.resolve.DescriptorResolver;
+import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver;
+import org.jetbrains.jet.lang.resolve.TypeResolver;
+import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
+import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider;
+import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
+import org.jetbrains.jet.lang.psi.JetImportsFactory;
+import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
+import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaPackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.java.lazy.GlobalJavaResolverContext;
+import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer;
+import org.jetbrains.annotations.NotNull;
+import javax.annotation.PreDestroy;
+
+/* This file is generated by org.jetbrains.jet.generators.injectors.InjectorsPackage. DO NOT EDIT! */
+@SuppressWarnings("ALL")
+public class InjectorForLazyResolveWithJava {
+    
+    private final Project project;
+    private final GlobalContextImpl globalContext;
+    private final LockBasedStorageManager lockBasedStorageManager;
+    private final DeclarationProviderFactory declarationProviderFactory;
+    private final BindingTrace bindingTrace;
+    private final ModuleDescriptorImpl module;
+    private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final ResolveSession resolveSession;
+    private final JavaDescriptorResolver javaDescriptorResolver;
+    private final VirtualFileFinder virtualFileFinder;
+    private final JavaClassFinderImpl javaClassFinder;
+    private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
+    private final LazyResolveBasedCache lazyResolveBasedCache;
+    private final TraceBasedErrorReporter traceBasedErrorReporter;
+    private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
+    private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
+    private final AnnotationResolver annotationResolver;
+    private final CallResolver callResolver;
+    private final ArgumentTypeResolver argumentTypeResolver;
+    private final ExpressionTypingServices expressionTypingServices;
+    private final CallExpressionResolver callExpressionResolver;
+    private final DescriptorResolver descriptorResolver;
+    private final DelegatedPropertyResolver delegatedPropertyResolver;
+    private final TypeResolver typeResolver;
+    private final QualifiedExpressionResolver qualifiedExpressionResolver;
+    private final CallResolverExtensionProvider callResolverExtensionProvider;
+    private final CandidateResolver candidateResolver;
+    private final JetImportsFactory jetImportsFactory;
+    private final ScopeProvider scopeProvider;
+    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
+    private final GlobalJavaResolverContext globalJavaResolverContext;
+    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
+    private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer;
+    
+    public InjectorForLazyResolveWithJava(
+        @NotNull Project project,
+        @NotNull GlobalContextImpl globalContext,
+        @NotNull DeclarationProviderFactory declarationProviderFactory,
+        @NotNull BindingTrace bindingTrace
+    ) {
+        this.project = project;
+        this.globalContext = globalContext;
+        this.lockBasedStorageManager = globalContext.getStorageManager();
+        this.declarationProviderFactory = declarationProviderFactory;
+        this.bindingTrace = bindingTrace;
+        this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule("<fake-jdr-module>");
+        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
+        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
+        this.javaClassFinder = new JavaClassFinderImpl();
+        this.virtualFileFinder = org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder.SERVICE.getInstance(project);
+        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver();
+        this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
+        this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
+        this.traceBasedErrorReporter = new TraceBasedErrorReporter();
+        this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
+        this.lazyResolveBasedCache = new LazyResolveBasedCache();
+        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache);
+        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule());
+        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
+        this.annotationResolver = new AnnotationResolver();
+        this.callResolver = new CallResolver();
+        this.argumentTypeResolver = new ArgumentTypeResolver();
+        this.expressionTypingServices = new ExpressionTypingServices(globalContext, platformToKotlinClassMap);
+        this.callExpressionResolver = new CallExpressionResolver();
+        this.descriptorResolver = new DescriptorResolver();
+        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
+        this.typeResolver = new TypeResolver();
+        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
+        this.callResolverExtensionProvider = new CallResolverExtensionProvider();
+        this.candidateResolver = new CandidateResolver();
+        this.jetImportsFactory = new JetImportsFactory();
+        this.scopeProvider = new ScopeProvider(getResolveSession());
+        this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(lockBasedStorageManager);
+
+        this.resolveSession.setAnnotationResolve(annotationResolver);
+        this.resolveSession.setDescriptorResolver(descriptorResolver);
+        this.resolveSession.setJetImportFactory(jetImportsFactory);
+        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
+        this.resolveSession.setScopeProvider(scopeProvider);
+        this.resolveSession.setTypeResolver(typeResolver);
+
+        javaClassFinder.setProject(project);
+
+        traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
+        traceBasedExternalSignatureResolver.setTrace(bindingTrace);
+
+        lazyResolveBasedCache.setSession(resolveSession);
+
+        traceBasedErrorReporter.setTrace(bindingTrace);
+
+        psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
+        psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
+
+        annotationResolver.setCallResolver(callResolver);
+        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+
+        callResolver.setArgumentTypeResolver(argumentTypeResolver);
+        callResolver.setCandidateResolver(candidateResolver);
+        callResolver.setExpressionTypingServices(expressionTypingServices);
+        callResolver.setTypeResolver(typeResolver);
+
+        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
+        argumentTypeResolver.setTypeResolver(typeResolver);
+
+        expressionTypingServices.setAnnotationResolver(annotationResolver);
+        expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
+        expressionTypingServices.setCallResolver(callResolver);
+        expressionTypingServices.setDescriptorResolver(descriptorResolver);
+        expressionTypingServices.setExtensionProvider(callResolverExtensionProvider);
+        expressionTypingServices.setProject(project);
+        expressionTypingServices.setTypeResolver(typeResolver);
+
+        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
+
+        descriptorResolver.setAnnotationResolver(annotationResolver);
+        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
+        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
+        descriptorResolver.setStorageManager(lockBasedStorageManager);
+        descriptorResolver.setTypeResolver(typeResolver);
+
+        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
+
+        typeResolver.setAnnotationResolver(annotationResolver);
+        typeResolver.setModuleDescriptor(module);
+        typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
+
+        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
+
+        jetImportsFactory.setProject(project);
+
+        deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer);
+        deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter);
+        deserializedDescriptorResolver.setJavaDescriptorResolver(javaDescriptorResolver);
+        deserializedDescriptorResolver.setJavaPackageFragmentProvider(lazyJavaPackageFragmentProvider);
+        deserializedDescriptorResolver.setStorageManager(lockBasedStorageManager);
+
+        annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter);
+        annotationDescriptorDeserializer.setJavaDescriptorResolver(javaDescriptorResolver);
+        annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileFinder);
+
+        javaClassFinder.initialize();
+
+    }
+    
+    @PreDestroy
+    public void destroy() {
+    }
+    
+    public ModuleDescriptorImpl getModule() {
+        return this.module;
+    }
+    
+    public ResolveSession getResolveSession() {
+        return this.resolveSession;
+    }
+    
+    public JavaDescriptorResolver getJavaDescriptorResolver() {
+        return this.javaDescriptorResolver;
+    }
+    
+}
@@ -28,9 +28,7 @@ import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything;
 import org.jetbrains.jet.context.ContextPackage;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.context.GlobalContextImpl;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
-import org.jetbrains.jet.di.InjectorForLazyResolve;
+import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.descriptors.DependencyKind;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -86,9 +84,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
    @NotNull
    @Override
    public ResolveSession getLazyResolveSession(@NotNull Project fileProject, @NotNull Collection<JetFile> files) {
-        BindingTraceContext javaResolverTrace = new BindingTraceContext();
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(fileProject, javaResolverTrace);
-        return createLazyResolveSession(fileProject, files, javaResolverTrace, injector, true);
+        return createLazyResolveSession(fileProject, files, new BindingTraceContext(), true);
    }

    @NotNull
@@ -96,23 +92,31 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
            @NotNull Project project,
            @NotNull Collection<JetFile> files,
            @NotNull BindingTrace trace,
-            @NotNull InjectorForJavaDescriptorResolver injector,
            boolean addBuiltIns
    ) {
+        GlobalContextImpl globalContext = ContextPackage.GlobalContext();
+
        // TODO: Replace with stub declaration provider
-        GlobalContextImpl globalContext = injector.getGlobalContext();
        FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(
                globalContext.getStorageManager(),
                files);

-        ModuleDescriptorImpl module = injector.getModule();
+        InjectorForLazyResolveWithJava resolveWithJava = new InjectorForLazyResolveWithJava(
+                project,
+                globalContext,
+                declarationProviderFactory,
+                trace);
+
+        resolveWithJava.getModule().addFragmentProvider(
+                DependencyKind.BINARIES, resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider());

        if (addBuiltIns) {
-            module.addFragmentProvider(DependencyKind.BUILT_INS,
-                                       KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
+            resolveWithJava.getModule().addFragmentProvider(
+                    DependencyKind.BUILT_INS,
+                    KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
        }

-        return new InjectorForLazyResolve(project, globalContext, module, declarationProviderFactory, trace).getResolveSession();
+        return resolveWithJava.getResolveSession();
    }

    @NotNull