diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java index 5be0854ab82..2e17d34e71d 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java +++ b/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) ); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java index 92e00669514..9b57b54f11b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java +++ b/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 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 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 files, BindingTrace trace, - TopDownAnalysisParameters topDownAnalysisParameters, + TopDownAnalysisMode topDownAnalysisMode, ModuleDescriptorImpl module, @Nullable List 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 { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java index 0e82780cc77..8af57873a30 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodiesResolveContext.java +++ b/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(); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index a2502006e9d..bf0acc7017a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/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(); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java index a3fdc05ab2a..a82abdbe6a5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java +++ b/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; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java index 5d2b05c58a8..8dc6525d9ac 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java +++ b/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 declarations, @NotNull DataFlowInfo outerDataFlowInfo ) { - final TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters, outerDataFlowInfo); + final TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisMode, outerDataFlowInfo); final Multimap topLevelFqNames = HashMultimap.create(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java index 00f1aa204c0..9558f4eddbe 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzerForTopLevel.java +++ b/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 files, @NotNull List 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 elements ) { - TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisParameters, elements, DataFlowInfo.EMPTY); + TopDownAnalysisContext c = lazyTopDownAnalyzer.analyzeDeclarations(topDownAnalysisMode, elements, DataFlowInfo.EMPTY); resolveImportsInAllFiles(c, resolveSession); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java index 104e6ed683a..234043bf145 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java +++ b/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 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) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisMode.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisMode.kt new file mode 100644 index 00000000000..84f6f406f2e --- /dev/null +++ b/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) +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java deleted file mode 100644 index 88eddb619c4..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java +++ /dev/null @@ -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; - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index 14416458101..c544ec0774c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/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 } } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 59d7c5ab118..c48fbca2764 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/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); diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java index 07e0b467acc..dca8126a85f 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java +++ b/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 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; } diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt index 2c99b75b743..7009500f262 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt +++ b/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 { + val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, object : Function { 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(null)) + return BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, Functions.constant(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 ) : BodiesResolveContext { @@ -473,6 +473,6 @@ public abstract class ElementResolver protected( override fun getOuterDataFlowInfo() = DataFlowInfo.EMPTY - override fun getTopDownAnalysisParameters() = topDownAnalysisParameters + override fun getTopDownAnalysisMode() = topDownAnalysisMode } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt index a111ed12d73..18a50dc322a 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt +++ b/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( diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java index f3a692315e7..1a8a6f27f66 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java +++ b/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 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.emptyList()); return JsAnalysisResult.success(trace, module); }