diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 7781ccb9729..503e8de9a96 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -55,6 +55,7 @@ import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -115,6 +116,7 @@ public class InjectorForLazyResolveWithJava { private final TypeResolver typeResolver; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -181,6 +183,7 @@ public class InjectorForLazyResolveWithJava { this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -234,6 +237,7 @@ public class InjectorForLazyResolveWithJava { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 92478fc1186..bcf7dc8e72c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -58,6 +58,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.context.LazinessToken; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -129,6 +130,7 @@ public class InjectorForTopDownAnalyzerForJvm { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final LazinessToken lazinessToken; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -206,6 +208,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.lazinessToken = new LazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazinessToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -287,6 +290,7 @@ public class InjectorForTopDownAnalyzerForJvm { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 47bcb1bb2bb..55995209cca 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.BodyResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -63,6 +64,7 @@ public class InjectorForBodyResolve { private final ModuleDescriptor moduleDescriptor; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final AdditionalCheckerProvider additionalCheckerProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final BodyResolver bodyResolver; private final AnnotationResolver annotationResolver; private final CallResolver callResolver; @@ -95,7 +97,8 @@ public class InjectorForBodyResolve { @NotNull GlobalContext globalContext, @NotNull BindingTrace bindingTrace, @NotNull ModuleDescriptor moduleDescriptor, - @NotNull AdditionalCheckerProvider additionalCheckerProvider + @NotNull AdditionalCheckerProvider additionalCheckerProvider, + @NotNull PartialBodyResolveProvider partialBodyResolveProvider ) { this.project = project; this.globalContext = globalContext; @@ -104,6 +107,7 @@ public class InjectorForBodyResolve { this.moduleDescriptor = moduleDescriptor; this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); this.additionalCheckerProvider = additionalCheckerProvider; + this.partialBodyResolveProvider = partialBodyResolveProvider; this.bodyResolver = new BodyResolver(); this.annotationResolver = new AnnotationResolver(); this.callResolver = new CallResolver(); @@ -160,6 +164,7 @@ public class InjectorForBodyResolve { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java index 1d14f0b30b0..1dfbd141cda 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyBodyResolve.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.context.LazinessToken; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -89,6 +90,7 @@ public class InjectorForLazyBodyResolve { private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -136,6 +138,7 @@ public class InjectorForLazyBodyResolve { this.lazinessToken = new LazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -186,6 +189,7 @@ public class InjectorForLazyBodyResolve { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index e69783e4717..1b03fbac0a3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -81,6 +82,7 @@ public class InjectorForLazyResolve { private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -122,6 +124,7 @@ public class InjectorForLazyResolve { this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -156,6 +159,7 @@ public class InjectorForLazyResolve { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index 252eba6448d..e00c828e318 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.DelegatedPropertyResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.types.expressions.ControlStructureTypingUtils; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker; @@ -67,6 +68,7 @@ public class InjectorForMacros { private final DescriptorResolver descriptorResolver; private final DelegatedPropertyResolver delegatedPropertyResolver; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final ControlStructureTypingUtils controlStructureTypingUtils; private final ExpressionTypingUtils expressionTypingUtils; private final ForLoopConventionsChecker forLoopConventionsChecker; @@ -98,6 +100,7 @@ public class InjectorForMacros { this.descriptorResolver = new DescriptorResolver(); this.delegatedPropertyResolver = new DelegatedPropertyResolver(); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.controlStructureTypingUtils = new ControlStructureTypingUtils(getExpressionTypingServices()); this.expressionTypingUtils = new ExpressionTypingUtils(getExpressionTypingServices(), getCallResolver()); this.forLoopConventionsChecker = new ForLoopConventionsChecker(); @@ -112,6 +115,7 @@ public class InjectorForMacros { this.expressionTypingServices.setCallResolver(callResolver); this.expressionTypingServices.setDescriptorResolver(descriptorResolver); this.expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + this.expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); this.expressionTypingServices.setProject(project); this.expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index f6f0d65b043..c03e0d6953c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -44,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.context.LazinessToken; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -94,6 +95,7 @@ public class InjectorForTopDownAnalyzerBasic { private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -145,6 +147,7 @@ public class InjectorForTopDownAnalyzerBasic { this.lazinessToken = new LazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -209,6 +212,7 @@ public class InjectorForTopDownAnalyzerBasic { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/PartialBodyResolveProvider.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/PartialBodyResolveProvider.kt new file mode 100644 index 00000000000..225cae57d39 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/PartialBodyResolveProvider.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve + +import org.jetbrains.jet.lang.psi.JetElement + +public open class PartialBodyResolveProvider { + public open val filter: ((JetElement) -> Boolean)? + get() = null + + class object { + public val NONE: PartialBodyResolveProvider = PartialBodyResolveProvider() + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java index 07aa2f1f38f..b7c29a571f5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java @@ -18,12 +18,9 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.base.Predicate; import com.intellij.psi.PsiFile; -import kotlin.Function1; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.context.LazinessToken; -import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.storage.ExceptionTracker; import org.jetbrains.jet.storage.StorageManager; @@ -45,7 +42,7 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo boolean analyzingBootstrapLibrary, boolean declaredLocally ) { - return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, null, analyzingBootstrapLibrary, + return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, analyzingBootstrapLibrary, declaredLocally, LAZY); } @@ -57,7 +54,7 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo boolean analyzingBootstrapLibrary, boolean declaredLocally ) { - return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, null, analyzingBootstrapLibrary, + return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, analyzingBootstrapLibrary, declaredLocally, true); } @@ -67,23 +64,12 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo @NotNull ExceptionTracker exceptionTracker, @NotNull Predicate analyzeCompletely ) { - return createForLocalDeclarations(storageManager, exceptionTracker, analyzeCompletely, null); - } - - @NotNull - public static TopDownAnalysisParameters createForLocalDeclarations( - @NotNull StorageManager storageManager, - @NotNull ExceptionTracker exceptionTracker, - @NotNull Predicate analyzeCompletely, - @Nullable Function1 statementFilter - ) { - return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, statementFilter, false, true, false); + return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, false, true, false); } @NotNull private final StorageManager storageManager; @NotNull private final ExceptionTracker exceptionTracker; @NotNull private final Predicate analyzeCompletely; - @Nullable private final Function1 statementFilter; private final boolean analyzingBootstrapLibrary; private final boolean declaredLocally; private final boolean lazyTopDownAnalysis; @@ -92,7 +78,6 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo @NotNull StorageManager storageManager, @NotNull ExceptionTracker exceptionTracker, @NotNull Predicate analyzeCompletely, - @Nullable Function1 statementFilter, boolean analyzingBootstrapLibrary, boolean declaredLocally, boolean lazyTopDownAnalysis @@ -100,7 +85,6 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo this.storageManager = storageManager; this.exceptionTracker = exceptionTracker; this.analyzeCompletely = analyzeCompletely; - this.statementFilter = statementFilter; this.analyzingBootstrapLibrary = analyzingBootstrapLibrary; this.declaredLocally = declaredLocally; this.lazyTopDownAnalysis = lazyTopDownAnalysis; @@ -123,11 +107,6 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo return analyzeCompletely; } - @Nullable - public Function1 getStatementFilter() { - return statementFilter; - } - public boolean isAnalyzingBootstrapLibrary() { return analyzingBootstrapLibrary; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index 308f0f39d42..265b247e0b8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -24,7 +24,6 @@ import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzerPackage; -import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; @@ -76,6 +75,8 @@ public class ExpressionTypingServices { private AnnotationResolver annotationResolver; @NotNull private CallResolverExtensionProvider extensionProvider; + @NotNull + private PartialBodyResolveProvider partialBodyResolveProvider; @NotNull public Project getProject() { @@ -142,10 +143,14 @@ public class ExpressionTypingServices { this.extensionProvider = extensionProvider; } - @Nullable - private Function1 getStatementFilter() { - GlobalContext context = expressionTypingComponents.globalContext; - return context instanceof TopDownAnalysisParameters ? ((TopDownAnalysisParameters) context).getStatementFilter() : null; + @NotNull + private PartialBodyResolveProvider getPartialBodyResolveProvider() { + return partialBodyResolveProvider; + } + + @Inject + public void setPartialBodyResolveProvider(@NotNull PartialBodyResolveProvider partialBodyResolveProvider) { + this.partialBodyResolveProvider = partialBodyResolveProvider; } public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) { @@ -215,7 +220,7 @@ public class ExpressionTypingServices { ) { List block = expression.getStatements(); - Function1 filter = getStatementFilter(); + Function1 filter = getPartialBodyResolveProvider().getFilter(); if (filter != null && !(expression instanceof JetPsiUtil.JetExpressionWrapper)) { block = KotlinPackage.filter(block, filter); } diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 5f2b1107778..1bf1fbb85c9 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.types.expressions.ForLoopConventionsChecker; import org.jetbrains.jet.lang.reflect.ReflectionTypes; import org.jetbrains.jet.lang.resolve.calls.CallExpressionResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.context.LazinessToken; @@ -72,6 +73,7 @@ public class InjectorForTests { private final ReflectionTypes reflectionTypes; private final CallExpressionResolver callExpressionResolver; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final QualifiedExpressionResolver qualifiedExpressionResolver; private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; @@ -106,6 +108,7 @@ public class InjectorForTests { this.reflectionTypes = new ReflectionTypes(moduleDescriptor); this.callExpressionResolver = new CallExpressionResolver(); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.descriptorResolver.setAnnotationResolver(annotationResolver); this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); @@ -118,6 +121,7 @@ public class InjectorForTests { this.expressionTypingServices.setCallResolver(callResolver); this.expressionTypingServices.setDescriptorResolver(descriptorResolver); this.expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + this.expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); this.expressionTypingServices.setProject(project); this.expressionTypingServices.setTypeResolver(typeResolver); diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt index 703f9bb183a..fa54baf0588 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt @@ -258,6 +258,7 @@ private fun generatorForBodyResolve() = parameter(javaClass()) parameter(javaClass(), useAsContext = true) parameter(javaClass()) + parameter(javaClass()) publicField(javaClass()) } diff --git a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java index 633da7780e4..558d0e19191 100644 --- a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java +++ b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java @@ -22,9 +22,7 @@ import com.google.common.base.Predicates; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; -import kotlin.Function1; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.analyzer.AnalyzerPackage; import org.jetbrains.jet.di.InjectorForBodyResolve; import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider; @@ -61,7 +59,7 @@ public abstract class ElementResolver { @NotNull public BindingContext getElementAdditionalResolve(@NotNull JetElement jetElement) { - return elementAdditionalResolve(jetElement, null); + return elementAdditionalResolve(jetElement, PartialBodyResolveProvider.NONE); } @NotNull @@ -97,7 +95,7 @@ public abstract class ElementResolver { if (partialBodyResolve && elementOfAdditionalResolve instanceof JetDeclaration) { //TODO: do not resolve with filter if whole body resolve cached already - Function1 filter = new PartialBodyResolveFilter( + PartialBodyResolveFilter filter = new PartialBodyResolveFilter( jetElement, (JetDeclaration) elementOfAdditionalResolve, probablyNothingCallableNames()); return elementAdditionalResolve(elementOfAdditionalResolve, filter); @@ -129,7 +127,7 @@ public abstract class ElementResolver { @NotNull protected BindingContext elementAdditionalResolve( @NotNull JetElement resolveElement, - @Nullable Function1 bodyResolveFilter + @NotNull PartialBodyResolveProvider partialResolveProvider ) { // All additional resolve should be done to separate trace BindingTrace trace = resolveSession.getStorageManager().createSafeTrace( @@ -138,13 +136,13 @@ public abstract class ElementResolver { JetFile file = resolveElement.getContainingJetFile(); if (resolveElement instanceof JetNamedFunction) { - functionAdditionalResolve(resolveSession, (JetNamedFunction) resolveElement, trace, file, bodyResolveFilter); + functionAdditionalResolve(resolveSession, (JetNamedFunction) resolveElement, trace, file, partialResolveProvider); } else if (resolveElement instanceof JetClassInitializer) { - initializerAdditionalResolve(resolveSession, (JetClassInitializer) resolveElement, trace, file, bodyResolveFilter); + initializerAdditionalResolve(resolveSession, (JetClassInitializer) resolveElement, trace, file, partialResolveProvider); } else if (resolveElement instanceof JetProperty) { - propertyAdditionalResolve(resolveSession, (JetProperty) resolveElement, trace, file, bodyResolveFilter); + propertyAdditionalResolve(resolveSession, (JetProperty) resolveElement, trace, file, partialResolveProvider); } else if (resolveElement instanceof JetDelegationSpecifierList) { delegationSpecifierAdditionalResolve(resolveSession, (JetDelegationSpecifierList) resolveElement, trace, file); @@ -158,7 +156,7 @@ public abstract class ElementResolver { annotationAdditionalResolve(resolveSession, (JetAnnotationEntry) resolveElement); } else if (resolveElement instanceof JetClass) { - constructorAdditionalResolve(resolveSession, (JetClass) resolveElement, trace, file, bodyResolveFilter); + constructorAdditionalResolve(resolveSession, (JetClass) resolveElement, trace, file, partialResolveProvider); } else if (resolveElement instanceof JetTypeParameter) { typeParameterAdditionalResolve(resolveSession, (JetTypeParameter) resolveElement); @@ -316,7 +314,7 @@ public abstract class ElementResolver { // Activate resolving of supertypes ForceResolveUtil.forceResolveAllContents(descriptor.getTypeConstructor().getSupertypes()); - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, null); + BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, PartialBodyResolveProvider.NONE); bodyResolver.resolveDelegationSpecifierList(createEmptyContext(resolveSession), classOrObject, descriptor, descriptor.getUnsubstitutedPrimaryConstructor(), descriptor.getScopeForClassHeaderResolution(), @@ -328,11 +326,12 @@ public abstract class ElementResolver { final JetProperty jetProperty, BindingTrace trace, JetFile file, - @Nullable Function1 bodyResolveFilter) { + @NotNull PartialBodyResolveProvider partialResolveProvider + ) { JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty); BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy( - createParameters(resolveSession, null), + createParameters(resolveSession), new Function() { @Override public JetScope apply(JetDeclaration declaration) { @@ -341,7 +340,7 @@ public abstract class ElementResolver { return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration); } }); - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, bodyResolveFilter); + BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider); PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty); ForceResolveUtil.forceResolveAllContents(descriptor); @@ -367,13 +366,13 @@ public abstract class ElementResolver { JetNamedFunction namedFunction, BindingTrace trace, JetFile file, - @Nullable Function1 bodyResolveFilter + @NotNull PartialBodyResolveProvider partialResolveProvider ) { JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction); FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); ForceResolveUtil.forceResolveAllContents(functionDescriptor); - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, bodyResolveFilter); + BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider); bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope); } @@ -382,7 +381,7 @@ public abstract class ElementResolver { JetClass klass, BindingTrace trace, JetFile file, - @Nullable Function1 bodyResolveFilter + @NotNull PartialBodyResolveProvider partialResolveProvider ) { JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass); @@ -393,7 +392,7 @@ public abstract class ElementResolver { classDescriptor, JetPsiUtil.getElementTextWithContext(klass)); - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, bodyResolveFilter); + BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider); bodyResolver.resolveConstructorParameterDefaultValuesAndAnnotations(createEmptyContext(resolveSession), trace, klass, constructorDescriptor, scope); } @@ -403,36 +402,36 @@ public abstract class ElementResolver { JetClassInitializer classInitializer, BindingTrace trace, JetFile file, - @Nullable Function1 filter + @NotNull PartialBodyResolveProvider partialResolveProvider ) { JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class); LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) resolveSession.resolveToDescriptor(classOrObject); - BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, filter); + BodyResolver bodyResolver = createBodyResolver(resolveSession, trace, file, partialResolveProvider); bodyResolver.resolveAnonymousInitializer(createEmptyContext(resolveSession), classInitializer, classOrObjectDescriptor); } - private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @Nullable Function1 statementFilter) { + private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @NotNull PartialBodyResolveProvider partialResolveProvider) { InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve( file.getProject(), - createParameters(resolveSession, statementFilter), + createParameters(resolveSession), trace, resolveSession.getModuleDescriptor(), - getAdditionalCheckerProvider(file) + getAdditionalCheckerProvider(file), + partialResolveProvider ); return bodyResolve.getBodyResolver(); } - private static TopDownAnalysisParameters createParameters(@NotNull ResolveSession resolveSession, @Nullable Function1 statementFilter) { + private static TopDownAnalysisParameters createParameters(@NotNull ResolveSession resolveSession) { return TopDownAnalysisParameters.createForLocalDeclarations( resolveSession.getStorageManager(), resolveSession.getExceptionTracker(), - Predicates.alwaysTrue(), - statementFilter); + Predicates.alwaysTrue()); } @NotNull private static BodyResolveContextForLazy createEmptyContext(@NotNull ResolveSession resolveSession) { - return new BodyResolveContextForLazy(createParameters(resolveSession, null), Functions.constant(null)); + return new BodyResolveContextForLazy(createParameters(resolveSession), Functions.constant(null)); } private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) { diff --git a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt index d4b817ebc7c..870c1769d63 100644 --- a/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt +++ b/idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/PartialBodyResolveFilter.kt @@ -35,13 +35,15 @@ class PartialBodyResolveFilter( elementToResolve: JetElement, private val declaration: JetDeclaration, probablyNothingCallableNames: ProbablyNothingCallableNames -) : (JetElement) -> Boolean { +) : org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider() { private val statementTree = StatementTree() private val nothingFunctionNames = HashSet(probablyNothingCallableNames.functionNames()) private val nothingPropertyNames = probablyNothingCallableNames.propertyNames() + override val filter: ((JetElement) -> Boolean)? = { it is JetExpression && statementTree.statementMark(it) != MarkLevel.NONE } + ;{ assert(declaration.isAncestor(elementToResolve)) @@ -130,9 +132,6 @@ class PartialBodyResolveFilter( return nameFilter } - override fun invoke(statement: JetElement) - = statement is JetExpression && statementTree.statementMark(statement) != MarkLevel.NONE - /** * Finds places within the given statement that may affect smart-casts after it. * That is, such places whose containing statements must be left in code to keep the smart-casts. diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index f7a46137055..2ee26db09e7 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.lazy.DefaultNothingCallableNames; import org.jetbrains.jet.lang.resolve.lazy.ElementResolver; import org.jetbrains.jet.lang.resolve.lazy.ProbablyNothingCallableNames; @@ -61,7 +62,7 @@ public class ResolveElementCache extends ElementResolver { manager.createWeaklyRetainedMemoizedFunction(new Function1() { @Override public BindingContext invoke(JetElement jetElement) { - return elementAdditionalResolve(jetElement, null); + return elementAdditionalResolve(jetElement, PartialBodyResolveProvider.NONE); } }); diff --git a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index 02ec49b21b9..34c62dd4e87 100644 --- a/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -44,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver; import org.jetbrains.jet.lang.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; import org.jetbrains.jet.context.LazinessToken; import org.jetbrains.jet.lang.resolve.calls.CallResolverExtensionProvider; +import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider; import org.jetbrains.jet.lang.resolve.calls.CallCompleter; import org.jetbrains.jet.lang.resolve.calls.CandidateResolver; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; @@ -94,6 +95,7 @@ public class InjectorForTopDownAnalyzerForJs { private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; private final LazinessToken lazinessToken; private final CallResolverExtensionProvider callResolverExtensionProvider; + private final PartialBodyResolveProvider partialBodyResolveProvider; private final CallCompleter callCompleter; private final CandidateResolver candidateResolver; private final TaskPrioritizer taskPrioritizer; @@ -144,6 +146,7 @@ public class InjectorForTopDownAnalyzerForJs { this.lazinessToken = new LazinessToken(); this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken); this.callResolverExtensionProvider = new CallResolverExtensionProvider(); + this.partialBodyResolveProvider = new PartialBodyResolveProvider(); this.candidateResolver = new CandidateResolver(); this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); this.taskPrioritizer = new TaskPrioritizer(storageManager); @@ -208,6 +211,7 @@ public class InjectorForTopDownAnalyzerForJs { expressionTypingServices.setCallResolver(callResolver); expressionTypingServices.setDescriptorResolver(descriptorResolver); expressionTypingServices.setExtensionProvider(callResolverExtensionProvider); + expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); expressionTypingServices.setProject(project); expressionTypingServices.setTypeResolver(typeResolver);