Better injecting of partial body resolve filter

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);
 

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);
 

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);
 

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);
 

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);
 

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()
+    }
+}

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<PsiFile> analyzeCompletely
     ) {
-        return createForLocalDeclarations(storageManager, exceptionTracker, analyzeCompletely, null);
-    }
-
-    @NotNull
-    public static TopDownAnalysisParameters createForLocalDeclarations(
-            @NotNull StorageManager storageManager,
-            @NotNull ExceptionTracker exceptionTracker,
-            @NotNull Predicate<PsiFile> analyzeCompletely,
-            @Nullable Function1<JetElement, Boolean> 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<PsiFile> analyzeCompletely;
-    @Nullable private final Function1<JetElement, Boolean> 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<PsiFile> analyzeCompletely,
-            @Nullable Function1<JetElement, Boolean> 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<JetElement, Boolean> getStatementFilter() {
-        return statementFilter;
-    }
-
     public boolean isAnalyzingBootstrapLibrary() {
         return analyzingBootstrapLibrary;
     }

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<JetElement, Boolean> 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<JetElement> block = expression.getStatements();
 
-        Function1<JetElement, Boolean> filter = getStatementFilter();
+        Function1<JetElement, Boolean> filter = getPartialBodyResolveProvider().getFilter();
         if (filter != null && !(expression instanceof JetPsiUtil.JetExpressionWrapper)) {
             block = KotlinPackage.filter(block, filter);
         }