azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LazyLocalClassifierAnalyzer introduced

Browse Source
This commit is contained in:
Andrey Breslav
2015-01-23 08:59:16 +03:00
parent 5b4682dd0e
commit 483e20affc
12 changed files with 435 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java
+4 -4
View File
@@ -42,6 +42,7 @@ import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.context.LazyResolveToken;
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -52,7 +53,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -107,6 +107,7 @@ public class InjectorForLazyResolveWithJava {
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
private final LazyResolveToken lazyResolveToken;
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
@@ -117,7 +118,6 @@ public class InjectorForLazyResolveWithJava {
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -178,6 +178,7 @@ public class InjectorForLazyResolveWithJava {
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.lazyResolveToken = new LazyResolveToken();
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
@@ -188,7 +189,6 @@ public class InjectorForLazyResolveWithJava {
this.dynamicTypesSettings = new DynamicTypesSettings();
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -272,7 +272,7 @@ public class InjectorForLazyResolveWithJava {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java
+4 -4
View File
@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
@@ -55,7 +56,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -122,6 +122,7 @@ public class InjectorForReplWithJava {
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final AdditionalFileScopeProvider additionalFileScopeProvider;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
@@ -132,7 +133,6 @@ public class InjectorForReplWithJava {
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -207,6 +207,7 @@ public class InjectorForReplWithJava {
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.additionalFileScopeProvider = additionalFileScopeProvider;
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
@@ -217,7 +218,6 @@ public class InjectorForReplWithJava {
this.dynamicTypesSettings = new DynamicTypesSettings();
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -325,7 +325,7 @@ public class InjectorForReplWithJava {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java
+4 -4
View File
@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -54,7 +55,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -122,6 +122,7 @@ public class InjectorForTopDownAnalyzerForJvm {
private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
@@ -131,7 +132,6 @@ public class InjectorForTopDownAnalyzerForJvm {
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -206,6 +206,7 @@ public class InjectorForTopDownAnalyzerForJvm {
this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -215,7 +216,6 @@ public class InjectorForTopDownAnalyzerForJvm {
this.dynamicTypesSettings = new DynamicTypesSettings();
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -324,7 +324,7 @@ public class InjectorForTopDownAnalyzerForJvm {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java
+4 -4
View File
@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
@@ -40,7 +41,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -82,6 +82,7 @@ public class InjectorForLazyBodyResolve {
private final DynamicTypesSettings dynamicTypesSettings;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
private final AdditionalFileScopeProvider additionalFileScopeProvider;
private final DeclarationScopeProviderImpl declarationScopeProvider;
@@ -95,7 +96,6 @@ public class InjectorForLazyBodyResolve {
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -139,6 +139,7 @@ public class InjectorForLazyBodyResolve {
this.dynamicTypesSettings = dynamicTypesSettings;
this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
@@ -152,7 +153,6 @@ public class InjectorForLazyBodyResolve {
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -240,7 +240,7 @@ public class InjectorForLazyBodyResolve {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java
+297
View File
@@ -0,0 +1,297 @@
/*
* Copyright 2010-2015 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.kotlin.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.kotlin.context.GlobalContext;
import org.jetbrains.kotlin.storage.StorageManager;
import org.jetbrains.kotlin.resolve.BindingTrace;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.BodyResolver;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
import org.jetbrains.kotlin.resolve.TypeResolver;
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
import org.jetbrains.kotlin.context.LazinessToken;
import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider;
import org.jetbrains.kotlin.resolve.calls.CallCompleter;
import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
import org.jetbrains.kotlin.resolve.DeclarationsChecker;
import org.jetbrains.kotlin.resolve.ModifiersChecker;
import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
import org.jetbrains.kotlin.resolve.DeclarationResolver;
import org.jetbrains.kotlin.resolve.ImportsResolver;
import org.jetbrains.kotlin.psi.JetImportsFactory;
import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
import org.jetbrains.kotlin.resolve.OverloadResolver;
import org.jetbrains.kotlin.resolve.OverrideResolver;
import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
import org.jetbrains.annotations.NotNull;
import javax.annotation.PreDestroy;
/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
@SuppressWarnings("all")
public class InjectorForLazyLocalClassifierAnalyzer {
private final Project project;
private final GlobalContext globalContext;
private final StorageManager storageManager;
private final BindingTrace bindingTrace;
private final ModuleDescriptor module;
private final KotlinBuiltIns kotlinBuiltIns;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
private final AdditionalCheckerProvider additionalCheckerProvider;
private final DynamicTypesSettings dynamicTypesSettings;
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
private final NoTopLevelDescriptorProvider noTopLevelDescriptorProvider;
private final NoFileScopeProvider noFileScopeProvider;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final BodyResolver bodyResolver;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
private final ExpressionTypingServices expressionTypingServices;
private final ExpressionTypingComponents expressionTypingComponents;
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
private final DelegatedPropertyResolver delegatedPropertyResolver;
private final TypeResolver typeResolver;
private final QualifiedExpressionResolver qualifiedExpressionResolver;
private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
private final LazinessToken lazinessToken;
private final PartialBodyResolveProvider partialBodyResolveProvider;
private final CallCompleter callCompleter;
private final CandidateResolver candidateResolver;
private final TaskPrioritizer taskPrioritizer;
private final ControlFlowAnalyzer controlFlowAnalyzer;
private final DeclarationsChecker declarationsChecker;
private final ModifiersChecker modifiersChecker;
private final FunctionAnalyzerExtension functionAnalyzerExtension;
private final ScriptBodyResolver scriptBodyResolver;
private final DeclarationResolver declarationResolver;
private final ImportsResolver importsResolver;
private final JetImportsFactory jetImportsFactory;
private final DeclarationScopeProviderImpl declarationScopeProvider;
private final LazyDeclarationResolver lazyDeclarationResolver;
private final OverloadResolver overloadResolver;
private final OverrideResolver overrideResolver;
private final VarianceChecker varianceChecker;
public InjectorForLazyLocalClassifierAnalyzer(
@NotNull Project project,
@NotNull GlobalContext globalContext,
@NotNull BindingTrace bindingTrace,
@NotNull ModuleDescriptor module,
@NotNull AdditionalCheckerProvider additionalCheckerProvider,
@NotNull DynamicTypesSettings dynamicTypesSettings
) {
this.project = project;
this.globalContext = globalContext;
this.storageManager = globalContext.getStorageManager();
this.bindingTrace = bindingTrace;
this.module = module;
this.kotlinBuiltIns = module.getBuiltIns();
this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
this.additionalCheckerProvider = additionalCheckerProvider;
this.dynamicTypesSettings = dynamicTypesSettings;
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$;
this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.bodyResolver = new BodyResolver();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
this.expressionTypingComponents = new ExpressionTypingComponents();
this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
this.delegatedPropertyResolver = new DelegatedPropertyResolver();
this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
this.lazinessToken = new LazinessToken();
this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings);
this.partialBodyResolveProvider = new PartialBodyResolveProvider();
this.candidateResolver = new CandidateResolver();
this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
this.taskPrioritizer = new TaskPrioritizer(storageManager);
this.controlFlowAnalyzer = new ControlFlowAnalyzer();
this.declarationsChecker = new DeclarationsChecker();
this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
this.scriptBodyResolver = new ScriptBodyResolver();
this.declarationResolver = new DeclarationResolver();
this.importsResolver = new ImportsResolver();
this.jetImportsFactory = new JetImportsFactory();
this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
this.overloadResolver = new OverloadResolver();
this.overrideResolver = new OverrideResolver();
this.varianceChecker = new VarianceChecker(bindingTrace);
this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider);
this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
this.lazyTopDownAnalyzer.setModuleDescriptor(module);
this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
this.lazyTopDownAnalyzer.setTrace(bindingTrace);
this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
bodyResolver.setAnnotationResolver(annotationResolver);
bodyResolver.setCallResolver(callResolver);
bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
bodyResolver.setDeclarationsChecker(declarationsChecker);
bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
bodyResolver.setExpressionTypingServices(expressionTypingServices);
bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
bodyResolver.setTrace(bindingTrace);
annotationResolver.setCallResolver(callResolver);
annotationResolver.setStorageManager(storageManager);
annotationResolver.setTypeResolver(typeResolver);
callResolver.setArgumentTypeResolver(argumentTypeResolver);
callResolver.setCallCompleter(callCompleter);
callResolver.setCandidateResolver(candidateResolver);
callResolver.setExpressionTypingServices(expressionTypingServices);
callResolver.setTaskPrioritizer(taskPrioritizer);
callResolver.setTypeResolver(typeResolver);
argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
argumentTypeResolver.setTypeResolver(typeResolver);
expressionTypingServices.setAnnotationResolver(annotationResolver);
expressionTypingServices.setBuiltIns(kotlinBuiltIns);
expressionTypingServices.setCallExpressionResolver(callExpressionResolver);
expressionTypingServices.setCallResolver(callResolver);
expressionTypingServices.setDescriptorResolver(descriptorResolver);
expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider);
expressionTypingServices.setProject(project);
expressionTypingServices.setTypeResolver(typeResolver);
expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
expressionTypingComponents.setCallResolver(callResolver);
expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices);
forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils);
forLoopConventionsChecker.setProject(project);
callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setAnnotationResolver(annotationResolver);
descriptorResolver.setBuiltIns(kotlinBuiltIns);
descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
descriptorResolver.setExpressionTypingServices(expressionTypingServices);
descriptorResolver.setStorageManager(storageManager);
descriptorResolver.setTypeResolver(typeResolver);
delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
delegatedPropertyResolver.setCallResolver(callResolver);
delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
controlFlowAnalyzer.setTrace(bindingTrace);
declarationsChecker.setDescriptorResolver(descriptorResolver);
declarationsChecker.setModifiersChecker(modifiersChecker);
declarationsChecker.setTrace(bindingTrace);
functionAnalyzerExtension.setTrace(bindingTrace);
scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
declarationResolver.setAnnotationResolver(annotationResolver);
declarationResolver.setDescriptorResolver(descriptorResolver);
declarationResolver.setImportsResolver(importsResolver);
declarationResolver.setTrace(bindingTrace);
importsResolver.setImportsFactory(jetImportsFactory);
importsResolver.setModuleDescriptor(module);
importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
importsResolver.setTrace(bindingTrace);
jetImportsFactory.setProject(project);
declarationScopeProvider.setFileScopeProvider(noFileScopeProvider);
lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
lazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
overloadResolver.setTrace(bindingTrace);
overrideResolver.setTrace(bindingTrace);
}
@PreDestroy
public void destroy() {
}
public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
return this.lazyTopDownAnalyzer;
}
}
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java
+4 -4
View File
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.context.LazyResolveToken;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -37,7 +38,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -74,6 +74,7 @@ public class InjectorForLazyResolve {
private final ResolveSession resolveSession;
private final ScopeProvider scopeProvider;
private final LazyResolveToken lazyResolveToken;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
@@ -82,7 +83,6 @@ public class InjectorForLazyResolve {
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -122,6 +122,7 @@ public class InjectorForLazyResolve {
this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
this.scopeProvider = new ScopeProvider(getResolveSession());
this.lazyResolveToken = new LazyResolveToken();
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -130,7 +131,6 @@ public class InjectorForLazyResolve {
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -193,7 +193,7 @@ public class InjectorForLazyResolve {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java
+4 -4
View File
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -38,7 +39,6 @@ import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -86,6 +86,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
private final DefaultProvider defaultProvider;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
@@ -95,7 +96,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
private final DynamicTypesSettings dynamicTypesSettings;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -144,6 +144,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
this.defaultProvider = DefaultProvider.INSTANCE$;
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -153,7 +154,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
this.dynamicTypesSettings = new DynamicTypesSettings();
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -242,7 +242,7 @@ public class InjectorForLazyTopDownAnalyzerBasic {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);
compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt
+61
View File
@@ -0,0 +1,61 @@
/*
* Copyright 2010-2015 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.kotlin.resolve
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer
import org.jetbrains.kotlin.context.GlobalContext
import org.jetbrains.kotlin.resolve.scopes.WritableScope
import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.psi.JetClassOrObject
import org.jetbrains.kotlin.types.DynamicTypesSettings
import com.google.common.base.Predicates
import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
public class LazyLocalClassifierAnalyzer : LocalClassifierAnalyzer() {
override fun processClassOrObject(
globalContext: GlobalContext,
scope: WritableScope?,
context: ExpressionTypingContext,
containingDeclaration: DeclarationDescriptor,
classOrObject: JetClassOrObject,
additionalCheckerProvider: AdditionalCheckerProvider,
dynamicTypesSettings: DynamicTypesSettings
) {
val topDownAnalysisParameters = TopDownAnalysisParameters.create(
globalContext.storageManager,
globalContext.exceptionTracker,
Predicates.equalTo(classOrObject.getContainingFile()), false, true)
val c = TopDownAnalysisContext(topDownAnalysisParameters)
c.setOuterDataFlowInfo(context.dataFlowInfo)
val injector = InjectorForLazyLocalClassifierAnalyzer(
classOrObject.getProject(),
globalContext,
context.trace,
DescriptorUtils.getContainingModule(containingDeclaration),
additionalCheckerProvider,
dynamicTypesSettings
)
injector.getLazyTopDownAnalyzer().analyzeDeclarations(
topDownAnalysisParameters,
listOf(classOrObject)
)
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt
+6
View File
@@ -21,4 +21,10 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
public trait FileScopeProvider {
fun getFileScope(jetFile: JetFile): JetScope
}
public object NoFileScopeProvider : FileScopeProvider {
override fun getFileScope(jetFile: JetFile): JetScope {
throw UnsupportedOperationException("Should not be called")
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt
+16
View File
@@ -29,3 +29,19 @@ public trait TopLevelDescriptorProvider {
fun getTopLevelClassDescriptors(fqName: FqName): Collection<ClassDescriptor>
}
public object NoTopLevelDescriptorProvider : TopLevelDescriptorProvider {
private fun shouldNotBeCalled(): Nothing = throw UnsupportedOperationException("Should not be called")
override fun getPackageFragment(fqName: FqName): LazyPackageDescriptor? {
shouldNotBeCalled()
}
override fun getScriptDescriptor(script: JetScript): ScriptDescriptor {
shouldNotBeCalled()
}
override fun getTopLevelClassDescriptors(fqName: FqName): Collection<ClassDescriptor> {
shouldNotBeCalled()
}
}
generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt
+27 -1
View File
@@ -51,6 +51,8 @@ import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
import org.jetbrains.kotlin.types.DynamicTypesAllowed
import org.jetbrains.kotlin.types.DynamicTypesSettings
import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
// NOTE: After making changes, you need to re-generate the injectors.
// To do that, you can run main in this file.
@@ -72,6 +74,7 @@ public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
listOf(
generatorForTopDownAnalyzerBasic(),
generatorForLazyTopDownAnalyzerBasic(),
generatorForLazyLocalClassifierAnalyzer(),
generatorForTopDownAnalyzerForJvm(),
generatorForJavaDescriptorResolver(),
generatorForLazyResolveWithJava(),
@@ -107,6 +110,23 @@ private fun generatorForLazyTopDownAnalyzerBasic() =
publicField<LazyTopDownAnalyzerForTopLevel>()
field<AdditionalCheckerProvider.DefaultProvider>()
field<LazyLocalClassifierAnalyzer>()
}
private fun generatorForLazyLocalClassifierAnalyzer() =
generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") {
parameter<Project>()
parameter<GlobalContext>(useAsContext = true)
parameter<BindingTrace>()
parameter<ModuleDescriptor>(name = "module", useAsContext = true)
parameter<AdditionalCheckerProvider>()
parameter<DynamicTypesSettings>()
publicField<LazyTopDownAnalyzer>()
field<NoTopLevelDescriptorProvider>()
field<NoFileScopeProvider>()
field<LazyLocalClassifierAnalyzer>()
}
private fun generatorForLazyBodyResolve() =
@@ -119,6 +139,7 @@ private fun generatorForLazyBodyResolve() =
parameter<DynamicTypesSettings>()
field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
field<LazyLocalClassifierAnalyzer>()
publicField<LazyTopDownAnalyzer>()
}
@@ -133,6 +154,7 @@ private fun generatorForTopDownAnalyzerForJs() =
field<MutablePackageFragmentProvider>()
field<KotlinJsCheckerProvider>()
field<DynamicTypesAllowed>()
field<LazyLocalClassifierAnalyzer>()
}
private fun generatorForTopDownAnalyzerForJvm() =
@@ -197,6 +219,7 @@ private fun generatorForLazyResolveWithJava() =
field<JavaFlexibleTypeCapabilitiesProvider>()
field<LazyResolveToken>()
field<JavaLazyAnalyzerPostConstruct>()
field<LazyLocalClassifierAnalyzer>()
field<KotlinJvmCheckerProvider>()
}
@@ -261,9 +284,10 @@ private fun generatorForLazyResolve() =
parameter<DynamicTypesSettings>()
publicField<ResolveSession>()
field<ScopeProvider>()
field<ScopeProvider>()
field<LazyResolveToken>()
field<LazyLocalClassifierAnalyzer>()
}
private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
@@ -309,6 +333,8 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
field<KotlinJvmCheckerProvider>()
field<VirtualFileFinder>(init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
field<LazyLocalClassifierAnalyzer>()
}
js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java
+4 -4
View File
@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
import org.jetbrains.kotlin.types.DynamicTypesAllowed;
import org.jetbrains.kotlin.resolve.LazyLocalClassifierAnalyzer;
import org.jetbrains.kotlin.resolve.AnnotationResolver;
import org.jetbrains.kotlin.resolve.calls.CallResolver;
import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
@@ -38,7 +39,6 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
import org.jetbrains.kotlin.types.reflect.ReflectionTypes;
import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
import org.jetbrains.kotlin.resolve.DescriptorResolver;
@@ -87,6 +87,7 @@ public class InjectorForTopDownAnalyzerForJs {
private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
private final KotlinJsCheckerProvider kotlinJsCheckerProvider;
private final DynamicTypesAllowed dynamicTypesAllowed;
private final LazyLocalClassifierAnalyzer lazyLocalClassifierAnalyzer;
private final AnnotationResolver annotationResolver;
private final CallResolver callResolver;
private final ArgumentTypeResolver argumentTypeResolver;
@@ -95,7 +96,6 @@ public class InjectorForTopDownAnalyzerForJs {
private final ControlStructureTypingUtils controlStructureTypingUtils;
private final ExpressionTypingUtils expressionTypingUtils;
private final ForLoopConventionsChecker forLoopConventionsChecker;
private final LocalClassifierAnalyzer localClassifierAnalyzer;
private final ReflectionTypes reflectionTypes;
private final CallExpressionResolver callExpressionResolver;
private final DescriptorResolver descriptorResolver;
@@ -145,6 +145,7 @@ public class InjectorForTopDownAnalyzerForJs {
this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
this.dynamicTypesAllowed = new DynamicTypesAllowed();
this.lazyLocalClassifierAnalyzer = new LazyLocalClassifierAnalyzer();
this.annotationResolver = new AnnotationResolver();
this.callResolver = new CallResolver();
this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -153,7 +154,6 @@ public class InjectorForTopDownAnalyzerForJs {
this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices);
this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns);
this.forLoopConventionsChecker = new ForLoopConventionsChecker();
this.localClassifierAnalyzer = new LocalClassifierAnalyzer();
this.reflectionTypes = new ReflectionTypes(module);
this.callExpressionResolver = new CallExpressionResolver();
this.descriptorResolver = new DescriptorResolver();
@@ -242,7 +242,7 @@ public class InjectorForTopDownAnalyzerForJs {
expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils);
expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
expressionTypingComponents.setGlobalContext(globalContext);
expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
expressionTypingComponents.setLocalClassifierAnalyzer(lazyLocalClassifierAnalyzer);
expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
expressionTypingComponents.setReflectionTypes(reflectionTypes);