From 483e20affc611b9c08c656499de22eff139649c3 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 23 Jan 2015 08:59:16 +0300 Subject: [PATCH] LazyLocalClassifierAnalyzer introduced --- .../di/InjectorForLazyResolveWithJava.java | 8 +- .../kotlin/di/InjectorForReplWithJava.java | 8 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 8 +- .../kotlin/di/InjectorForLazyBodyResolve.java | 8 +- ...njectorForLazyLocalClassifierAnalyzer.java | 297 ++++++++++++++++++ .../kotlin/di/InjectorForLazyResolve.java | 8 +- .../InjectorForLazyTopDownAnalyzerBasic.java | 8 +- .../resolve/LazyLocalClassifierAnalyzer.kt | 61 ++++ .../kotlin/resolve/lazy/FileScopeProvider.kt | 6 + .../lazy/TopLevelDescriptorProvider.kt | 16 + .../generators/injectors/GenerateInjectors.kt | 28 +- .../di/InjectorForTopDownAnalyzerForJs.java | 8 +- 12 files changed, 435 insertions(+), 29 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java index a1c425553e8..701d2332cd4 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java @@ -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); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java index d22c8f28175..1b9dd5cbf3e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java @@ -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); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java index 8d37a4e0622..5e4f9ce599b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java @@ -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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index 10431940630..a8f9051970d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java @@ -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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java new file mode 100644 index 00000000000..9f5546b9831 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java @@ -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; + } + +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java index bb4a6a14867..fc5376dd2f3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java @@ -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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java index 8c9706db87e..143e84cdf1f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java @@ -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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt new file mode 100644 index 00000000000..c5991794b3b --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyLocalClassifierAnalyzer.kt @@ -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) + ) + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt index 0aa65dc5187..7c245aac4fd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeProvider.kt @@ -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") + } } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt index c837121c095..be578e44e37 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/TopLevelDescriptorProvider.kt @@ -29,3 +29,19 @@ public trait TopLevelDescriptorProvider { fun getTopLevelClassDescriptors(fqName: FqName): Collection } + +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 { + shouldNotBeCalled() + } +} \ No newline at end of file diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index 19ae63ac564..019a8c30bb2 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -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 = listOf( generatorForTopDownAnalyzerBasic(), generatorForLazyTopDownAnalyzerBasic(), + generatorForLazyLocalClassifierAnalyzer(), generatorForTopDownAnalyzerForJvm(), generatorForJavaDescriptorResolver(), generatorForLazyResolveWithJava(), @@ -107,6 +110,23 @@ private fun generatorForLazyTopDownAnalyzerBasic() = publicField() field() + field() + } + +private fun generatorForLazyLocalClassifierAnalyzer() = + generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") { + parameter() + parameter(useAsContext = true) + parameter() + parameter(name = "module", useAsContext = true) + parameter() + parameter() + + publicField() + + field() + field() + field() } private fun generatorForLazyBodyResolve() = @@ -119,6 +139,7 @@ private fun generatorForLazyBodyResolve() = parameter() field(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true) + field() publicField() } @@ -133,6 +154,7 @@ private fun generatorForTopDownAnalyzerForJs() = field() field() field() + field() } private fun generatorForTopDownAnalyzerForJvm() = @@ -197,6 +219,7 @@ private fun generatorForLazyResolveWithJava() = field() field() field() + field() field() } @@ -261,9 +284,10 @@ private fun generatorForLazyResolve() = parameter() publicField() - field() + field() field() + field() } private fun DependencyInjectorGenerator.commonForResolveSessionBased() { @@ -309,6 +333,8 @@ private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() { field() field(init = GivenExpression(javaClass().getName() + ".SERVICE.getInstance(project)")) + + field() } diff --git a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java index d154a18cfbd..52e6be2884b 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java @@ -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);