Refactor: TopDownAnalysisParameters -> TopDownAnalysisMode

No longer implements TypeLazinessToken (was unused)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -112,8 +112,6 @@ public class ReplInterpreter {
 
         GlobalContextImpl context = ContextPackage.GlobalContext();
 
-        TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(true);
-
         scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory();
 
         ScopeProvider.AdditionalFileScopeProvider scopeProvider = new ScopeProvider.AdditionalFileScopeProvider() {
@@ -134,7 +132,7 @@ public class ReplInterpreter {
                 scopeProvider
         );
 
-        this.topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters, DataFlowInfo.EMPTY);
+        this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY);
         this.topDownAnalyzer = injector.getLazyTopDownAnalyzerForTopLevel();
         this.resolveSession = injector.getResolveSession();
 
@@ -353,7 +351,7 @@ public class ReplInterpreter {
                 new FileBasedDeclarationProviderFactory(resolveSession.getStorageManager(), Collections.singletonList(psiFile)));
 
         TopDownAnalysisContext context = topDownAnalyzer.analyzeDeclarations(
-                topDownAnalysisContext.getTopDownAnalysisParameters(),
+                topDownAnalysisContext.getTopDownAnalysisMode(),
                 Collections.singletonList(psiFile)
         );
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.ImportPath;
-import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters;
+import org.jetbrains.kotlin.resolve.TopDownAnalysisMode;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 
 import java.util.ArrayList;
@@ -75,10 +75,10 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull GlobalContext globalContext,
             @NotNull Collection<JetFile> files,
             @NotNull BindingTrace trace,
-            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
+            @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @NotNull ModuleDescriptorImpl module
     ) {
-        return analyzeFilesWithJavaIntegration(project, globalContext, files, trace, topDownAnalysisParameters, module, null, null);
+        return analyzeFilesWithJavaIntegration(project, globalContext, files, trace, topDownAnalysisMode, module, null, null);
     }
 
     @NotNull
@@ -91,12 +91,8 @@ public enum TopDownAnalyzerFacadeForJVM {
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCacheProvider incrementalCacheProvider
     ) {
-        TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(
-                false
-        );
-
         return analyzeFilesWithJavaIntegration(
-                project, globalContext, files, trace, topDownAnalysisParameters, module,
+                project, globalContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, module,
                 moduleIds, incrementalCacheProvider);
     }
 
@@ -106,7 +102,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             @NotNull GlobalContext globalContext,
             Collection<JetFile> files,
             BindingTrace trace,
-            TopDownAnalysisParameters topDownAnalysisParameters,
+            TopDownAnalysisMode topDownAnalysisMode,
             ModuleDescriptorImpl module,
             @Nullable List<String> moduleIds,
             @Nullable IncrementalCacheProvider incrementalCacheProvider
@@ -143,7 +139,7 @@ public enum TopDownAnalyzerFacadeForJVM {
             }
             additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
 
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, allFiles, additionalProviders);
+            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders);
             return AnalysisResult.success(trace.getBindingContext(), module);
         }
         finally {

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java

@@ -20,7 +20,6 @@ import com.google.common.base.Function;
 import org.jetbrains.annotations.Mutable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.ReadOnly;
-import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -51,5 +50,5 @@ public interface BodiesResolveContext {
     DataFlowInfo getOuterDataFlowInfo();
 
     @NotNull
-    TopDownAnalysisParameters getTopDownAnalysisParameters();
+    TopDownAnalysisMode getTopDownAnalysisMode();
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -134,7 +134,7 @@ public class BodyResolver {
         // SCRIPT: resolve script bodies
         scriptBodyResolverResolver.resolveScriptBodies(c);
 
-        if (!c.getTopDownAnalysisParameters().isDeclaredLocally()) {
+        if (!c.getTopDownAnalysisMode().getIsLocalDeclarations()) {
             computeDeferredTypes();
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java

@@ -74,7 +74,7 @@ public class ControlFlowAnalyzer {
         // A pseudocode of class/object initialization corresponds to a class/object
         // or initialization of properties corresponds to a package declared in a file
         JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetElement) declarationContainer, trace);
-        if (c.getTopDownAnalysisParameters().isDeclaredLocally()) {
+        if (c.getTopDownAnalysisMode().getIsLocalDeclarations()) {
             flowInformationProvider.checkForLocalClassOrObjectMode();
             return;
         }
@@ -95,7 +95,7 @@ public class ControlFlowAnalyzer {
     private void checkFunction(@NotNull BodiesResolveContext c, @NotNull JetDeclarationWithBody function, @Nullable JetType expectedReturnType) {
         if (!function.hasBody()) return;
         JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider(function, trace);
-        if (c.getTopDownAnalysisParameters().isDeclaredLocally()) {
+        if (c.getTopDownAnalysisMode().getIsLocalDeclarations()) {
             flowInformationProvider.checkForLocalClassOrObjectMode();
             return;
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java

@@ -118,11 +118,11 @@ public class LazyTopDownAnalyzer {
 
     @NotNull
     public TopDownAnalysisContext analyzeDeclarations(
-            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
+            @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @NotNull Collection<? extends PsiElement> declarations,
             @NotNull DataFlowInfo outerDataFlowInfo
     ) {
-        final TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters, outerDataFlowInfo);
+        final TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo);
 
         final Multimap<FqName, JetElement> topLevelFqNames = HashMultimap.create();
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java

@@ -50,7 +50,7 @@ public class LazyTopDownAnalyzerForTopLevel {
 
     @NotNull
     public TopDownAnalysisContext analyzeFiles(
-            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
+            @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @NotNull Collection<JetFile> files,
             @NotNull List<? extends PackageFragmentProvider> additionalProviders
     ) {
@@ -66,15 +66,15 @@ public class LazyTopDownAnalyzerForTopLevel {
 
         ((ModuleDescriptorImpl) resolveSession.getModuleDescriptor()).initialize(provider);
 
-        return analyzeDeclarations(topDownAnalysisParameters, files);
+        return analyzeDeclarations(topDownAnalysisMode, files);
     }
 
     @NotNull
     public TopDownAnalysisContext analyzeDeclarations(
-            @NotNull TopDownAnalysisParameters topDownAnalysisParameters,
+            @NotNull TopDownAnalysisMode topDownAnalysisMode,
             @NotNull Collection<? extends PsiElement> elements
     ) {
-        TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisParameters, elements, DataFlowInfo.EMPTY);
+        TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisMode, elements, DataFlowInfo.EMPTY);
 
         resolveImportsInAllFiles(c, resolveSession);
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java

@@ -26,8 +26,6 @@ import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.storage.ExceptionTracker;
-import org.jetbrains.kotlin.storage.StorageManager;
 
 import java.io.PrintStream;
 import java.util.Collection;
@@ -52,19 +50,19 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
 
     private final Map<JetScript, ScriptDescriptor> scripts = Maps.newLinkedHashMap();
 
-    private final TopDownAnalysisParameters topDownAnalysisParameters;
+    private final TopDownAnalysisMode topDownAnalysisMode;
 
     private StringBuilder debugOutput;
 
-    public TopDownAnalysisContext(@NotNull TopDownAnalysisParameters topDownAnalysisParameters, @NotNull DataFlowInfo outerDataFlowInfo) {
-        this.topDownAnalysisParameters = topDownAnalysisParameters;
+    public TopDownAnalysisContext(@NotNull TopDownAnalysisMode topDownAnalysisMode, @NotNull DataFlowInfo outerDataFlowInfo) {
+        this.topDownAnalysisMode = topDownAnalysisMode;
         this.outerDataFlowInfo = outerDataFlowInfo;
     }
 
     @Override
     @NotNull
-    public TopDownAnalysisParameters getTopDownAnalysisParameters() {
-        return topDownAnalysisParameters;
+    public TopDownAnalysisMode getTopDownAnalysisMode() {
+        return topDownAnalysisMode;
     }
 
     public void debug(Object message) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisMode.kt

@@ -0,0 +1,22 @@
+/*
+ * 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
+
+public enum class TopDownAnalysisMode(public val isLocalDeclarations: Boolean) {
+    LocalDeclarations : TopDownAnalysisMode(true)
+    TopLevelDeclarations : TopDownAnalysisMode(false)
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java

@@ -1,65 +0,0 @@
-/*
- * 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 com.google.common.base.Predicate;
-import com.intellij.psi.PsiFile;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.storage.ExceptionTracker;
-import org.jetbrains.kotlin.storage.StorageManager;
-
-/**
- * Various junk that cannot be placed into context (yet).
- */
-public class TopDownAnalysisParameters extends TypeLazinessToken {
-
-    @NotNull
-    public static TopDownAnalysisParameters create(
-            boolean declaredLocally
-    ) {
-        return new TopDownAnalysisParameters(declaredLocally, true);
-    }
-
-    @NotNull
-    public static TopDownAnalysisParameters createForLocalDeclarations() {
-        return new TopDownAnalysisParameters(true, false);
-    }
-
-    private final boolean declaredLocally;
-    private final boolean lazyTopDownAnalysis;
-
-    private TopDownAnalysisParameters(
-            boolean declaredLocally,
-            boolean lazyTopDownAnalysis
-    ) {
-        this.declaredLocally = declaredLocally;
-        this.lazyTopDownAnalysis = lazyTopDownAnalysis;
-    }
-
-    public boolean isDeclaredLocally() {
-        return declaredLocally;
-    }
-
-    // Used temporarily while we are transitioning from eager to lazy analysis of headers in the IDE
-    @Override
-    @Deprecated
-    public boolean isLazy() {
-        return lazyTopDownAnalysis;
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -16,36 +16,33 @@
 
 package org.jetbrains.kotlin.types.expressions
 
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.resolve.scopes.WritableScope
-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
-import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
-import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl
+import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
+import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver
+import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
-import org.jetbrains.kotlin.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider
-import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider
-import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
-import org.jetbrains.kotlin.name.SpecialNames
-import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil
+import org.jetbrains.kotlin.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider
+import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
+import org.jetbrains.kotlin.resolve.scopes.WritableScope
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.DynamicTypesSettings
 
 public class LocalClassifierAnalyzer(
         val descriptorResolver: DescriptorResolver,
@@ -62,8 +59,6 @@ public class LocalClassifierAnalyzer(
             additionalCheckerProvider: AdditionalCheckerProvider,
             dynamicTypesSettings: DynamicTypesSettings
     ) {
-        val topDownAnalysisParameters = TopDownAnalysisParameters.create(true)
-
         val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration)
         val injector = InjectorForLazyLocalClassifierAnalyzer(
                 classOrObject.getProject(),
@@ -87,7 +82,7 @@ public class LocalClassifierAnalyzer(
         )
 
         injector.getLazyTopDownAnalyzer().analyzeDeclarations(
-                topDownAnalysisParameters,
+                TopDownAnalysisMode.LocalDeclarations,
                 listOf(classOrObject),
                 context.dataFlowInfo
         )
@@ -113,7 +108,7 @@ class LocalClassDescriptorHolder(
     fun insideMyClass(element: PsiElement): Boolean = PsiTreeUtil.isAncestor(myClass, element, false)
 
     fun getClassDescriptor(classOrObject: JetClassOrObject, declarationScopeProvider: DeclarationScopeProvider): ClassDescriptor {
-        assert(isMyClass(classOrObject)) {"Called on a wrong class: ${classOrObject.getDebugText()}"}
+        assert(isMyClass(classOrObject)) { "Called on a wrong class: ${classOrObject.getDebugText()}" }
         if (classDescriptor == null) {
             classDescriptor = LazyClassDescriptor(
                     object : LazyClassContext {
@@ -148,7 +143,7 @@ class LocalClassDescriptorHolder(
     }
 
     fun getResolutionScopeForClass(classOrObject: JetClassOrObject): JetScope {
-        assert (isMyClass(classOrObject)) {"Called on a wrong class: ${classOrObject.getDebugText()}"}
+        assert (isMyClass(classOrObject)) { "Called on a wrong class: ${classOrObject.getDebugText()}" }
         return expressionTypingContext.scope
     }
 }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
-import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters;
+import org.jetbrains.kotlin.resolve.TopDownAnalysisMode;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor;
@@ -150,16 +150,12 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
 
-        TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create(
-                false
-        );
-
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
                 environment.getProject(),
                 ContextPackage.GlobalContext(),
                 environment.getSourceFiles(),
                 trace,
-                parameters,
+                TopDownAnalysisMode.TopLevelDeclarations,
                 module);
 
         PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);

compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters;
+import org.jetbrains.kotlin.resolve.TopDownAnalysisMode;
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM;
 
 import java.util.Collections;
@@ -55,8 +55,9 @@ public class LazyResolveTestUtil {
     public static ModuleDescriptor resolve(@NotNull Project project, @NotNull BindingTrace trace, @NotNull List<JetFile> sourceFiles) {
         ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule();
 
-        TopDownAnalysisParameters params = TopDownAnalysisParameters.create(false);
-        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(project, ContextPackage.GlobalContext(), sourceFiles, trace, params, module);
+        TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationNoIncremental(
+                project, ContextPackage.GlobalContext(), sourceFiles, trace, TopDownAnalysisMode.TopLevelDeclarations, module
+        );
 
         return module;
     }

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt

@@ -305,7 +305,7 @@ public abstract class ElementResolver protected(
     private fun propertyAdditionalResolve(resolveSession: ResolveSession, jetProperty: JetProperty, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter) {
         val propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty)
 
-        val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisParameters.createForLocalDeclarations(), object : Function<JetDeclaration, JetScope> {
+        val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, object : Function<JetDeclaration, JetScope> {
             override fun apply(declaration: JetDeclaration?): JetScope? {
                 assert(declaration!!.getParent() == jetProperty) { "Must be called only for property accessors, but called for " + declaration }
                 return resolveSession.getScopeProvider().getResolutionScopeForDeclaration(declaration)
@@ -379,7 +379,7 @@ public abstract class ElementResolver protected(
     }
 
     private fun createEmptyContext(): BodyResolveContextForLazy {
-        return BodyResolveContextForLazy(TopDownAnalysisParameters.createForLocalDeclarations(), Functions.constant<JetScope>(null))
+        return BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, Functions.constant<JetScope>(null))
     }
 
     private fun getExpressionResolutionScope(resolveSession: ResolveSession, expression: JetExpression): JetScope {
@@ -451,7 +451,7 @@ public abstract class ElementResolver protected(
     protected abstract fun getAdditionalCheckerProvider(jetFile: JetFile): AdditionalCheckerProvider
 
     private class BodyResolveContextForLazy(
-            private val topDownAnalysisParameters: TopDownAnalysisParameters,
+            private val topDownAnalysisMode: TopDownAnalysisMode,
             private val declaringScopes: Function<in JetDeclaration, JetScope>
     ) : BodiesResolveContext {
 
@@ -473,6 +473,6 @@ public abstract class ElementResolver protected(
 
         override fun getOuterDataFlowInfo() = DataFlowInfo.EMPTY
 
-        override fun getTopDownAnalysisParameters() = topDownAnalysisParameters
+        override fun getTopDownAnalysisMode() = topDownAnalysisMode
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -233,7 +233,7 @@ private object KotlinResolveDataProvider {
             ).getLazyTopDownAnalyzerForTopLevel()!!
 
             lazyTopDownAnalyzer.analyzeDeclarations(
-                    TopDownAnalysisParameters.create(false),
+                    TopDownAnalysisMode.TopLevelDeclarations,
                     listOf(analyzableElement)
             )
             return AnalysisResult.success(

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java

@@ -78,8 +78,6 @@ public final class TopDownAnalyzerFacadeForJS {
         Project project = config.getProject();
 
         GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-        TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(
-                false);
 
         Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
 
@@ -87,7 +85,7 @@ public final class TopDownAnalyzerFacadeForJS {
                 project, globalContext, trace, module,
                 new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), allFiles));
         try {
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, files,
+            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files,
                                                            Collections.<PackageFragmentProvider>emptyList());
             return JsAnalysisResult.success(trace, module);
         }