001    /*
002     * Copyright 2010-2015 JetBrains s.r.o.
003     *
004     * Licensed under the Apache License, Version 2.0 (the "License");
005     * you may not use this file except in compliance with the License.
006     * You may obtain a copy of the License at
007     *
008     * http://www.apache.org/licenses/LICENSE-2.0
009     *
010     * Unless required by applicable law or agreed to in writing, software
011     * distributed under the License is distributed on an "AS IS" BASIS,
012     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     * See the License for the specific language governing permissions and
014     * limitations under the License.
015     */
016    
017    package org.jetbrains.kotlin.di;
018    
019    import com.intellij.openapi.project.Project;
020    import org.jetbrains.kotlin.context.GlobalContext;
021    import org.jetbrains.kotlin.storage.StorageManager;
022    import org.jetbrains.kotlin.resolve.BindingTrace;
023    import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
024    import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
025    import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
026    import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
027    import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
028    import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
029    import com.intellij.psi.search.GlobalSearchScope;
030    import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver;
031    import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
032    import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
033    import org.jetbrains.kotlin.load.java.JavaClassFinderImpl;
034    import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver;
035    import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache;
036    import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter;
037    import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker;
038    import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver;
039    import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
040    import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl;
041    import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
042    import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
043    import org.jetbrains.kotlin.context.LazyResolveToken;
044    import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
045    import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
046    import org.jetbrains.kotlin.resolve.AnnotationResolver;
047    import org.jetbrains.kotlin.resolve.calls.CallResolver;
048    import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
049    import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
050    import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
051    import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
052    import org.jetbrains.kotlin.types.DynamicTypesSettings;
053    import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
054    import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
055    import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
056    import org.jetbrains.kotlin.resolve.DescriptorResolver;
057    import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
058    import org.jetbrains.kotlin.resolve.TypeResolver;
059    import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
060    import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
061    import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
062    import org.jetbrains.kotlin.resolve.StatementFilter;
063    import org.jetbrains.kotlin.resolve.calls.CallCompleter;
064    import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
065    import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
066    import org.jetbrains.kotlin.psi.JetImportsFactory;
067    import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
068    import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
069    import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
070    import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
071    import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
072    import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
073    import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver;
074    import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
075    import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder;
076    import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl;
077    import org.jetbrains.annotations.NotNull;
078    import javax.annotation.PreDestroy;
079    
080    /* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
081    @SuppressWarnings("all")
082    public class InjectorForLazyResolveWithJava {
083    
084        private final Project project;
085        private final GlobalContext globalContext;
086        private final StorageManager storageManager;
087        private final BindingTrace bindingTrace;
088        private final ModuleDescriptorImpl module;
089        private final KotlinBuiltIns kotlinBuiltIns;
090        private final PlatformToKotlinClassMap platformToKotlinClassMap;
091        private final DeclarationProviderFactory declarationProviderFactory;
092        private final ResolveSession resolveSession;
093        private final ScopeProvider scopeProvider;
094        private final GlobalSearchScope moduleContentScope;
095        private final ModuleClassResolver moduleClassResolver;
096        private final JavaDescriptorResolver javaDescriptorResolver;
097        private final VirtualFileFinder virtualFileFinder;
098        private final JavaClassFinderImpl javaClassFinder;
099        private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
100        private final LazyResolveBasedCache lazyResolveBasedCache;
101        private final TraceBasedErrorReporter traceBasedErrorReporter;
102        private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
103        private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
104        private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
105        private final SamConversionResolverImpl samConversionResolver;
106        private final JavaSourceElementFactoryImpl javaSourceElementFactory;
107        private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
108        private final LazyResolveToken lazyResolveToken;
109        private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
110        private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
111        private final AnnotationResolver annotationResolver;
112        private final CallResolver callResolver;
113        private final ArgumentTypeResolver argumentTypeResolver;
114        private final ExpressionTypingServices expressionTypingServices;
115        private final ExpressionTypingComponents expressionTypingComponents;
116        private final ControlStructureTypingUtils controlStructureTypingUtils;
117        private final DynamicTypesSettings dynamicTypesSettings;
118        private final ExpressionTypingUtils expressionTypingUtils;
119        private final ForLoopConventionsChecker forLoopConventionsChecker;
120        private final LocalClassifierAnalyzer localClassifierAnalyzer;
121        private final DescriptorResolver descriptorResolver;
122        private final DelegatedPropertyResolver delegatedPropertyResolver;
123        private final TypeResolver typeResolver;
124        private final QualifiedExpressionResolver qualifiedExpressionResolver;
125        private final ReflectionTypes reflectionTypes;
126        private final CallExpressionResolver callExpressionResolver;
127        private final StatementFilter statementFilter;
128        private final CallCompleter callCompleter;
129        private final CandidateResolver candidateResolver;
130        private final TaskPrioritizer taskPrioritizer;
131        private final JetImportsFactory jetImportsFactory;
132        private final LazyDeclarationResolver lazyDeclarationResolver;
133        private final DeclarationScopeProviderImpl declarationScopeProvider;
134        private final ScriptBodyResolver scriptBodyResolver;
135        private final AdditionalFileScopeProvider additionalFileScopeProvider;
136        private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
137        private final GlobalJavaResolverContext globalJavaResolverContext;
138        private final DeserializedDescriptorResolver deserializedDescriptorResolver;
139        private final DeserializationComponentsForJava deserializationComponentsForJava;
140        private final JavaClassDataFinder javaClassDataFinder;
141        private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
142    
143        public InjectorForLazyResolveWithJava(
144            @NotNull Project project,
145            @NotNull GlobalContext globalContext,
146            @NotNull BindingTrace bindingTrace,
147            @NotNull ModuleDescriptorImpl module,
148            @NotNull DeclarationProviderFactory declarationProviderFactory,
149            @NotNull GlobalSearchScope moduleContentScope,
150            @NotNull ModuleClassResolver moduleClassResolver
151        ) {
152            this.project = project;
153            this.globalContext = globalContext;
154            this.storageManager = globalContext.getStorageManager();
155            this.bindingTrace = bindingTrace;
156            this.module = module;
157            this.kotlinBuiltIns = module.getBuiltIns();
158            this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
159            this.declarationProviderFactory = declarationProviderFactory;
160            this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
161            this.scopeProvider = new ScopeProvider(getResolveSession());
162            this.moduleContentScope = moduleContentScope;
163            this.moduleClassResolver = moduleClassResolver;
164            this.javaClassFinder = new JavaClassFinderImpl();
165            this.virtualFileFinder = org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
166            this.traceBasedErrorReporter = new TraceBasedErrorReporter();
167            this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter);
168            this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
169            this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
170            this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
171            this.lazyResolveBasedCache = new LazyResolveBasedCache();
172            this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
173            this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
174            this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
175            this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
176            this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module);
177            this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module);
178            this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
179            this.lazyResolveToken = new LazyResolveToken();
180            this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
181            this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
182            this.annotationResolver = new AnnotationResolver();
183            this.callResolver = new CallResolver();
184            this.argumentTypeResolver = new ArgumentTypeResolver();
185            this.expressionTypingComponents = new ExpressionTypingComponents();
186            this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
187            this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
188            this.dynamicTypesSettings = new DynamicTypesSettings();
189            this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
190            this.forLoopConventionsChecker = new ForLoopConventionsChecker();
191            this.descriptorResolver = new DescriptorResolver();
192            this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
193            this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
194            this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver);
195            this.delegatedPropertyResolver = new DelegatedPropertyResolver();
196            this.reflectionTypes = new ReflectionTypes(module);
197            this.callExpressionResolver = new CallExpressionResolver();
198            this.statementFilter = new StatementFilter();
199            this.candidateResolver = new CandidateResolver();
200            this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
201            this.taskPrioritizer = new TaskPrioritizer(storageManager);
202            this.jetImportsFactory = new JetImportsFactory();
203            this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
204            this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
205            this.scriptBodyResolver = new ScriptBodyResolver();
206            this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
207            this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
208            this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, virtualFileFinder, traceBasedErrorReporter);
209            this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
210    
211            this.resolveSession.setAnnotationResolve(annotationResolver);
212            this.resolveSession.setDescriptorResolver(descriptorResolver);
213            this.resolveSession.setJetImportFactory(jetImportsFactory);
214            this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
215            this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
216            this.resolveSession.setScopeProvider(scopeProvider);
217            this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
218            this.resolveSession.setTypeResolver(typeResolver);
219    
220            scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
221            scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
222    
223            javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
224            javaClassFinder.setProject(project);
225            javaClassFinder.setScope(moduleContentScope);
226    
227            traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
228            traceBasedExternalSignatureResolver.setProject(project);
229            traceBasedExternalSignatureResolver.setTrace(bindingTrace);
230    
231            lazyResolveBasedCache.setSession(resolveSession);
232    
233            traceBasedErrorReporter.setTrace(bindingTrace);
234    
235            psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
236            psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
237    
238            javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession);
239            javaLazyAnalyzerPostConstruct.setProject(project);
240            javaLazyAnalyzerPostConstruct.setTrace(bindingTrace);
241    
242            annotationResolver.setCallResolver(callResolver);
243            annotationResolver.setStorageManager(storageManager);
244            annotationResolver.setTypeResolver(typeResolver);
245    
246            callResolver.setArgumentTypeResolver(argumentTypeResolver);
247            callResolver.setCallCompleter(callCompleter);
248            callResolver.setCandidateResolver(candidateResolver);
249            callResolver.setExpressionTypingServices(expressionTypingServices);
250            callResolver.setTaskPrioritizer(taskPrioritizer);
251            callResolver.setTypeResolver(typeResolver);
252    
253            argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
254            argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
255            argumentTypeResolver.setTypeResolver(typeResolver);
256    
257            expressionTypingServices.setAnnotationResolver(annotationResolver);
258            expressionTypingServices.setBuiltIns(kotlinBuiltIns);
259            expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
260            expressionTypingServices.setCallResolver(callResolver);
261            expressionTypingServices.setDescriptorResolver(descriptorResolver);
262            expressionTypingServices.setProject(project);
263            expressionTypingServices.setStatementFilter(statementFilter);
264            expressionTypingServices.setTypeResolver(typeResolver);
265    
266            expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
267            expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
268            expressionTypingComponents.setCallResolver(callResolver);
269            expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
270            expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
271            expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
272            expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
273            expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
274            expressionTypingComponents.setGlobalContext(globalContext);
275            expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
276            expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
277            expressionTypingComponents.setReflectionTypes(reflectionTypes);
278    
279            forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
280            forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
281            forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
282            forLoopConventionsChecker.setProject(project);
283    
284            descriptorResolver.setAnnotationResolver(annotationResolver);
285            descriptorResolver.setBuiltIns(kotlinBuiltIns);
286            descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
287            descriptorResolver.setExpressionTypingServices(expressionTypingServices);
288            descriptorResolver.setStorageManager(storageManager);
289            descriptorResolver.setTypeResolver(typeResolver);
290    
291            delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
292            delegatedPropertyResolver.setCallResolver(callResolver);
293            delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
294    
295            callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
296    
297            candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
298    
299            jetImportsFactory.setProject(project);
300    
301            lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
302            lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
303    
304            declarationScopeProvider.setFileScopeProvider(scopeProvider);
305    
306            scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
307    
308            deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
309    
310            javaClassFinder.initialize();
311    
312            javaLazyAnalyzerPostConstruct.postCreate();
313    
314        }
315    
316        @PreDestroy
317        public void destroy() {
318        }
319    
320        public ResolveSession getResolveSession() {
321            return this.resolveSession;
322        }
323    
324        public JavaDescriptorResolver getJavaDescriptorResolver() {
325            return this.javaDescriptorResolver;
326        }
327    
328    }