Changed way to pass statementFilter from ElementResolver into ExpressionTypingServices

compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java

@@ -75,11 +75,6 @@ public class BodyResolver {
         this.expressionTypingServices = expressionTypingServices;
     }
 
-    @NotNull
-    public ExpressionTypingServices getExpressionTypingServices() {
-        return expressionTypingServices;
-    }
-
     @Inject
     public void setCallResolver(@NotNull CallResolver callResolver) {
         this.callResolver = callResolver;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisParameters.java

@@ -18,9 +18,12 @@ 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;
 
@@ -42,7 +45,7 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo
             boolean analyzingBootstrapLibrary,
             boolean declaredLocally
     ) {
-        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, analyzingBootstrapLibrary,
+        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, null, analyzingBootstrapLibrary,
                                              declaredLocally, LAZY);
     }
 
@@ -54,7 +57,7 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo
             boolean analyzingBootstrapLibrary,
             boolean declaredLocally
     ) {
-        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, analyzingBootstrapLibrary,
+        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, null, analyzingBootstrapLibrary,
                                              declaredLocally, true);
     }
 
@@ -64,15 +67,23 @@ public class TopDownAnalysisParameters extends LazinessToken implements GlobalCo
             @NotNull ExceptionTracker exceptionTracker,
             @NotNull Predicate<PsiFile> analyzeCompletely
     ) {
-        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, false, true, false);
+        return createForLocalDeclarations(storageManager, exceptionTracker, analyzeCompletely, null);
     }
 
     @NotNull
-    private final StorageManager storageManager;
+    public static TopDownAnalysisParameters createForLocalDeclarations(
-    @NotNull
+            @NotNull StorageManager storageManager,
-    private final ExceptionTracker exceptionTracker;
+            @NotNull ExceptionTracker exceptionTracker,
-    @NotNull
+            @NotNull Predicate<PsiFile> analyzeCompletely,
-    private final Predicate<PsiFile> analyzeCompletely;
+            @Nullable Function1<JetElement, Boolean> statementFilter
+    ) {
+        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, statementFilter, 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;
@@ -81,6 +92,7 @@ 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
@@ -88,6 +100,7 @@ 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;
@@ -110,6 +123,11 @@ 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,6 +24,7 @@ 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;
@@ -75,8 +76,6 @@ public class ExpressionTypingServices {
     private AnnotationResolver annotationResolver;
     @NotNull
     private CallResolverExtensionProvider extensionProvider;
-    @Nullable
-    private Function1<JetElement, Boolean> filter;
 
     @NotNull
     public Project getProject() {
@@ -144,12 +143,9 @@ public class ExpressionTypingServices {
     }
 
     @Nullable
-    public Function1<JetElement, Boolean> getFilter() {
+    private Function1<JetElement, Boolean> getStatementFilter() {
-        return filter;
+        GlobalContext context = expressionTypingComponents.globalContext;
-    }
+        return context instanceof TopDownAnalysisParameters ? ((TopDownAnalysisParameters) context).getStatementFilter() : null;
-
-    public void setFilter(@Nullable Function1<JetElement, Boolean> filter) {
-        this.filter = filter;
     }
 
     public ExpressionTypingServices(@NotNull ExpressionTypingComponents components) {
@@ -219,6 +215,7 @@ public class ExpressionTypingServices {
     ) {
         List<JetElement> block = expression.getStatements();
 
+        Function1<JetElement, Boolean> filter = getStatementFilter();
         if (filter != null && !(expression instanceof JetPsiUtil.JetExpressionWrapper)) {
             block = KotlinPackage.filter(block, filter);
         }

idea/ide-common/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java

@@ -338,7 +338,7 @@ public abstract class ElementResolver {
         JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty);
 
         BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy(
-                createParameters(resolveSession),
+                createParameters(resolveSession, null),
                 new Function<JetDeclaration, JetScope>() {
                     @Override
                     public JetScope apply(JetDeclaration declaration) {
@@ -418,28 +418,27 @@ public abstract class ElementResolver {
         bodyResolver.resolveAnonymousInitializer(createEmptyContext(resolveSession), classInitializer, classOrObjectDescriptor);
     }
 
-    private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @Nullable Function1<JetElement, Boolean> filter) {
+    private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file, @Nullable Function1<JetElement, Boolean> statementFilter) {
         InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(
                 file.getProject(),
-                createParameters(resolveSession),
+                createParameters(resolveSession, statementFilter),
                 trace,
                 resolveSession.getModuleDescriptor(),
                 getAdditionalCheckerProvider(file)
         );
-        BodyResolver resolver = bodyResolve.getBodyResolver();
+        return bodyResolve.getBodyResolver();
-        resolver.getExpressionTypingServices().setFilter(filter);
-        return resolver;
     }
 
-    private static TopDownAnalysisParameters createParameters(@NotNull ResolveSession resolveSession) {
+    private static TopDownAnalysisParameters createParameters(@NotNull ResolveSession resolveSession, @Nullable Function1<JetElement, Boolean> statementFilter) {
         return TopDownAnalysisParameters.createForLocalDeclarations(
                 resolveSession.getStorageManager(), resolveSession.getExceptionTracker(),
-                Predicates.<PsiFile>alwaysTrue());
+                Predicates.<PsiFile>alwaysTrue(),
+                statementFilter);
     }
 
     @NotNull
     private static BodyResolveContextForLazy createEmptyContext(@NotNull ResolveSession resolveSession) {
-        return new BodyResolveContextForLazy(createParameters(resolveSession), Functions.<JetScope>constant(null));
+        return new BodyResolveContextForLazy(createParameters(resolveSession, null), Functions.<JetScope>constant(null));
     }
 
     private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) {