From bbb59773aa314afdf0772e73024bc3078e6a0d92 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 29 Jan 2015 19:21:25 +0300 Subject: [PATCH] filesToAnalyzeCompletely removed --- .../jetbrains/kotlin/cli/js/K2JSCompiler.java | 4 +-- .../compiler/KotlinToJVMBytecodeCompiler.java | 3 -- .../kotlin/cli/jvm/repl/ReplInterpreter.java | 3 -- .../jvm/TopDownAnalyzerFacadeForJVM.java | 4 --- .../resolve/TopDownAnalysisContext.java | 8 +---- .../resolve/TopDownAnalysisParameters.java | 16 ++------- .../expressions/LocalClassifierAnalyzer.kt | 5 +-- .../checkers/AbstractJetDiagnosticsTest.java | 3 -- ...bstractJetDiagnosticsTestWithJsStdLib.java | 4 +-- .../kotlin/codegen/CodegenTestUtil.java | 5 +-- .../kotlin/codegen/GenerationUtils.java | 4 +-- .../jvm/compiler/AbstractLoadJavaTest.java | 5 +-- .../jvm/compiler/LoadDescriptorUtil.java | 4 +-- .../kotlin/resolve/ExpectedResolveData.java | 4 +-- ...DescriptorResolveWithoutAnalyzeBodyTest.kt | 4 +-- .../kotlin/resolve/lazy/JvmResolveUtil.java | 17 ++++------ .../resolve/lazy/LazyResolveTestUtil.java | 3 -- .../AbstractLocalClassProtoTest.kt | 2 +- .../jetbrains/kotlin/test/JetTestUtils.java | 9 ----- .../types/AbstractJetTypeBindingTest.kt | 2 +- .../kotlin/resolve/lazy/ElementResolver.java | 6 ++-- .../idea/caches/resolve/KotlinResolveCache.kt | 8 +---- .../references/BuiltInsReferenceResolver.java | 5 +-- .../DecompiledTextConsistencyTest.kt | 5 +-- .../AbstractDiagnosticMessageJsTest.java | 4 +-- .../analyze/TopDownAnalyzerFacadeForJS.java | 33 ++----------------- .../LibrarySourcesConfigWithCaching.java | 3 -- .../kotlin/js/facade/K2JSTranslator.java | 4 +-- .../NoInternalVisibilityInStdLibTest.kt | 3 +- 29 files changed, 33 insertions(+), 147 deletions(-) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java index 05cd5c0869d..9a11a20d811 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java @@ -17,12 +17,10 @@ package org.jetbrains.kotlin.cli.js; import com.google.common.base.Joiner; -import com.google.common.base.Predicates; import com.intellij.openapi.Disposable; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiFile; import com.intellij.util.Function; import com.intellij.util.SmartList; import com.intellij.util.containers.ContainerUtil; @@ -212,7 +210,7 @@ public class K2JSCompiler extends CLICompiler { analyzerWithCompilerReport.analyzeAndReport(sources, new Function0() { @Override public AnalysisResult invoke() { - return TopDownAnalyzerFacadeForJS.analyzeFiles(sources, Predicates.alwaysTrue(), config); + return TopDownAnalyzerFacadeForJS.analyzeFiles(sources, config); } }); return analyzerWithCompilerReport.hasErrors(); diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 06427b4457a..38fe44eb9a8 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -16,12 +16,10 @@ package org.jetbrains.kotlin.cli.jvm.compiler; -import com.google.common.base.Predicates; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.intellij.openapi.Disposable; import com.intellij.openapi.util.Disposer; -import com.intellij.psi.PsiFile; import com.intellij.util.ArrayUtil; import kotlin.Function0; import kotlin.Function1; @@ -304,7 +302,6 @@ public class KotlinToJVMBytecodeCompiler { ContextPackage.GlobalContext(), environment.getSourceFiles(), sharedTrace, - Predicates.alwaysTrue(), analyzeModule, environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS), environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER) 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 13395a98f97..1536315cec1 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 @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.cli.jvm.repl; -import com.google.common.base.Predicates; import com.google.common.base.Throwables; import com.google.common.collect.Lists; import com.intellij.openapi.Disposable; @@ -24,7 +23,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Pair; import com.intellij.openapi.vfs.CharsetToolkit; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import com.intellij.psi.PsiFileFactory; import com.intellij.psi.impl.PsiFileFactoryImpl; import com.intellij.psi.search.ProjectScope; @@ -117,7 +115,6 @@ public class ReplInterpreter { TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( context.getStorageManager(), context.getExceptionTracker(), - Predicates.alwaysTrue(), false, true ); 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 f997b385b8a..a2629fd3048 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 @@ -16,9 +16,7 @@ package org.jetbrains.kotlin.resolve.jvm; -import com.google.common.base.Predicate; import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiFile; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -88,7 +86,6 @@ public enum TopDownAnalyzerFacadeForJVM { @NotNull GlobalContext globalContext, @NotNull Collection files, @NotNull BindingTrace trace, - @NotNull Predicate filesToAnalyzeCompletely, @NotNull ModuleDescriptorImpl module, @Nullable List moduleIds, @Nullable IncrementalCacheProvider incrementalCacheProvider @@ -96,7 +93,6 @@ public enum TopDownAnalyzerFacadeForJVM { TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), - filesToAnalyzeCompletely, false, false ); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java index 7aa80418987..115638618c6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java @@ -20,7 +20,6 @@ import com.google.common.base.Function; import com.google.common.base.Functions; import com.google.common.collect.Maps; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import kotlin.Function1; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; @@ -89,12 +88,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext { @Override public boolean completeAnalysisNeeded(@NotNull PsiElement element) { - PsiFile containingFile = element.getContainingFile(); - boolean result = containingFile != null && topDownAnalysisParameters.getAnalyzeCompletely().apply(containingFile); - if (!result) { - debug(containingFile); - } - return result; + return true; } @Override diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java index 8db8abb73b8..e6cbad1fd1c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java @@ -33,26 +33,23 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob public static TopDownAnalysisParameters create( @NotNull StorageManager storageManager, @NotNull ExceptionTracker exceptionTracker, - @NotNull Predicate analyzeCompletely, boolean analyzingBootstrapLibrary, boolean declaredLocally ) { - return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, analyzingBootstrapLibrary, + return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzingBootstrapLibrary, declaredLocally, true); } @NotNull public static TopDownAnalysisParameters createForLocalDeclarations( @NotNull StorageManager storageManager, - @NotNull ExceptionTracker exceptionTracker, - @NotNull Predicate analyzeCompletely + @NotNull ExceptionTracker exceptionTracker ) { - return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzeCompletely, false, true, false); + return new TopDownAnalysisParameters(storageManager, exceptionTracker, false, true, false); } @NotNull private final StorageManager storageManager; @NotNull private final ExceptionTracker exceptionTracker; - @NotNull private final Predicate analyzeCompletely; private final boolean analyzingBootstrapLibrary; private final boolean declaredLocally; private final boolean lazyTopDownAnalysis; @@ -60,14 +57,12 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob private TopDownAnalysisParameters( @NotNull StorageManager storageManager, @NotNull ExceptionTracker exceptionTracker, - @NotNull Predicate analyzeCompletely, boolean analyzingBootstrapLibrary, boolean declaredLocally, boolean lazyTopDownAnalysis ) { this.storageManager = storageManager; this.exceptionTracker = exceptionTracker; - this.analyzeCompletely = analyzeCompletely; this.analyzingBootstrapLibrary = analyzingBootstrapLibrary; this.declaredLocally = declaredLocally; this.lazyTopDownAnalysis = lazyTopDownAnalysis; @@ -85,11 +80,6 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob return exceptionTracker; } - @NotNull - public Predicate getAnalyzeCompletely() { - return analyzeCompletely; - } - public boolean isAnalyzingBootstrapLibrary() { return analyzingBootstrapLibrary; } 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 3a4acf8a208..0a095c7c108 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -67,10 +67,7 @@ public class LocalClassifierAnalyzer( additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings ) { - val topDownAnalysisParameters = TopDownAnalysisParameters.create( - globalContext.storageManager, - globalContext.exceptionTracker, - Predicates.equalTo(classOrObject.getContainingFile()), false, true) + val topDownAnalysisParameters = TopDownAnalysisParameters.create(globalContext.storageManager, globalContext.exceptionTracker, false, true) val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration) val injector = InjectorForLazyLocalClassifierAnalyzer( diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java index 2b089d5c5b4..702ba32e534 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java @@ -17,12 +17,10 @@ package org.jetbrains.kotlin.checkers; import com.google.common.base.Predicate; -import com.google.common.base.Predicates; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Sets; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import kotlin.Function1; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; @@ -230,7 +228,6 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest { context, jetFiles, moduleTrace, - Predicates.alwaysTrue(), module, null, null diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java index e71d2550ed0..7d8027dd19a 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java @@ -16,9 +16,7 @@ package org.jetbrains.kotlin.checkers; -import com.google.common.base.Predicates; import com.intellij.openapi.Disposable; -import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; @@ -70,7 +68,7 @@ public abstract class AbstractJetDiagnosticsTestWithJsStdLib extends AbstractJet BindingContext libraryContext = config.getLibraryContext(); DelegatingBindingTrace trace = new DelegatingBindingTrace(libraryContext, "trace with preanalyzed library"); - TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, Predicates.alwaysTrue(), config); + TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, config); trace.addAllMyDataTo(moduleTrace); } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java index 11c2720a19d..6baefc7702a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java @@ -16,9 +16,7 @@ package org.jetbrains.kotlin.codegen; -import com.google.common.base.Predicates; import com.intellij.openapi.util.SystemInfo; -import com.intellij.psi.PsiFile; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -53,8 +51,7 @@ public class CodegenTestUtil { public static ClassFileFactory generateFiles(@NotNull JetCoreEnvironment environment, @NotNull CodegenTestFiles files) { AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( environment.getProject(), - files.getPsiFiles(), - Predicates.alwaysTrue() + files.getPsiFiles() ); analysisResult.throwIfError(); AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java index 19cae5201e5..b1be865c415 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java @@ -16,9 +16,7 @@ package org.jetbrains.kotlin.codegen; -import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.codegen.state.GenerationState; @@ -49,7 +47,7 @@ public class GenerationUtils { @NotNull public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List files) { AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - project, files, Predicates.alwaysTrue()); + project, files); return compileFilesGetGenerationState(project, analysisResult, files); } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index e171ae20b88..1d981a577ba 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -16,10 +16,8 @@ package org.jetbrains.kotlin.jvm.compiler; -import com.google.common.base.Predicates; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.psi.PsiFile; import junit.framework.ComparisonFailure; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.analyzer.AnalysisResult; @@ -152,7 +150,6 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create( new LockBasedStorageManager(), new ExceptionTracker(), // dummy - Predicates.alwaysFalse(), false, false ); @@ -192,7 +189,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { JetFile jetFile = JetTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - environment.getProject(), Collections.singleton(jetFile), Predicates.alwaysTrue() + environment.getProject(), Collections.singleton(jetFile) ); PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); assertNotNull(packageView); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index 7172a921f39..213ac82de1f 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java @@ -16,11 +16,9 @@ package org.jetbrains.kotlin.jvm.compiler; -import com.google.common.base.Predicates; import com.intellij.openapi.Disposable; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.psi.PsiFile; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; @@ -145,7 +143,7 @@ public final class LoadDescriptorUtil { } }); AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( - jetCoreEnvironment.getProject(), jetFiles, Predicates.alwaysTrue()); + jetCoreEnvironment.getProject(), jetFiles); return new JetFilesAndAnalysisResult(jetFiles, result); } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java index 827b52b4527..57b4f8a25f2 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java @@ -16,12 +16,10 @@ package org.jetbrains.kotlin.resolve; -import com.google.common.base.Predicates; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import com.intellij.psi.PsiQualifiedNamedElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; @@ -141,7 +139,7 @@ public abstract class ExpectedResolveData { Project project = files.iterator().next().getProject(); AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration( - project, files, Predicates.alwaysTrue()); + project, files); return analysisResult.getBindingContext(); } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt index 9898e51b115..9a1ec9a71b2 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.annotation import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.psi.JetFile -import org.jetbrains.kotlin.test.JetTestUtils +import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil class AnnotationDescriptorResolveWithoutAnalyzeBodyTest : AnnotationDescriptorResolveTest() { @@ -26,5 +26,5 @@ class AnnotationDescriptorResolveWithoutAnalyzeBodyTest : AnnotationDescriptorRe checkAnnotationOnAllExceptLocalDeclarations(content, expectedAnnotation) } - override fun analyzeFile(ktFile: JetFile): AnalysisResult = JetTestUtils.analyzeFileWithoutBody(ktFile) + override fun analyzeFile(ktFile: JetFile): AnalysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(ktFile.getProject(), setOf(ktFile)); } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java index 4abbcd5d407..08212d7701c 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java @@ -16,10 +16,7 @@ package org.jetbrains.kotlin.resolve.lazy; -import com.google.common.base.Predicate; -import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; @@ -48,21 +45,20 @@ public class JvmResolveUtil { @NotNull public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) { - return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), - Predicates.alwaysTrue()); + return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file) + ); } @NotNull public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors( @NotNull Project project, - @NotNull Collection files, - @NotNull Predicate filesToAnalyzeCompletely + @NotNull Collection files ) { for (JetFile file : files) { AnalyzingUtils.checkForSyntacticErrors(file); } - AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, filesToAnalyzeCompletely); + AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files); AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); @@ -72,8 +68,7 @@ public class JvmResolveUtil { @NotNull public static AnalysisResult analyzeFilesWithJavaIntegration( @NotNull Project project, - @NotNull Collection files, - @NotNull Predicate filesToAnalyzeCompletely + @NotNull Collection files ) { ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule(""); module.addDependencyOnModule(module); @@ -83,6 +78,6 @@ public class JvmResolveUtil { BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace(); return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext( - project, ContextPackage.GlobalContext(), files, trace, filesToAnalyzeCompletely, module, null, null); + project, ContextPackage.GlobalContext(), files, trace, module, null, null); } } diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java index 3bd72d50cab..3b0d9f48338 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java @@ -16,10 +16,8 @@ package org.jetbrains.kotlin.resolve.lazy; -import com.google.common.base.Predicates; import com.google.common.collect.Sets; import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment; @@ -62,7 +60,6 @@ public class LazyResolveTestUtil { TopDownAnalysisParameters params = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), - Predicates.alwaysTrue(), false, false ); diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt index 87a78119163..c5faea96732 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt @@ -61,7 +61,7 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() { val module = TopDownAnalyzerFacadeForJVM.createSealedJavaModule() val globalContext = GlobalContext() val params = TopDownAnalysisParameters.create( - globalContext.storageManager, globalContext.exceptionTracker, Predicates.alwaysTrue(), false, false + globalContext.storageManager, globalContext.exceptionTracker, false, false ) val providerFactory = FileBasedDeclarationProviderFactory(globalContext.storageManager, emptyList()) diff --git a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java index cac3c0590e2..964dc5fdb0a 100644 --- a/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.test; -import com.google.common.base.Predicates; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; import com.google.common.collect.Maps; @@ -30,7 +29,6 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.CharsetToolkit; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import com.intellij.psi.PsiFileFactory; import com.intellij.psi.impl.PsiFileFactoryImpl; import com.intellij.rt.execution.junit.FileComparisonFailure; @@ -248,13 +246,6 @@ public class JetTestUtils { return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file); } - @NotNull - public static AnalysisResult analyzeFileWithoutBody(@NotNull JetFile file) { - return JvmResolveUtil.analyzeFilesWithJavaIntegration(file.getProject(), - Collections.singleton(file), - Predicates.alwaysFalse()); - } - @NotNull public static JetCoreEnvironment createEnvironmentWithFullJdk(Disposable disposable) { return createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(disposable, diff --git a/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt b/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt index 473b1c3e95a..f905e81583c 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt @@ -35,7 +35,7 @@ abstract class AbstractJetTypeBindingTest : JetLiteFixture() { val testFile = File(path) val testKtFile = loadJetFile(getProject(), testFile) - val analyzeResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(getProject(), listOf(testKtFile), { true }) + val analyzeResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(getProject(), listOf(testKtFile)) val testDeclaration = testKtFile.getDeclarations().last!! as JetCallableDeclaration diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java index 7480a9a6cfc..649e8412568 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java +++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java @@ -18,9 +18,7 @@ package org.jetbrains.kotlin.resolve.lazy; import com.google.common.base.Function; import com.google.common.base.Functions; -import com.google.common.base.Predicates; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; import com.intellij.psi.util.PsiTreeUtil; import kotlin.KotlinPackage; import org.jetbrains.annotations.NotNull; @@ -456,8 +454,8 @@ public abstract class ElementResolver { private static TopDownAnalysisParameters createParameters(@NotNull ResolveSession resolveSession) { return TopDownAnalysisParameters.createForLocalDeclarations( - resolveSession.getStorageManager(), resolveSession.getExceptionTracker(), - Predicates.alwaysTrue()); + resolveSession.getStorageManager(), resolveSession.getExceptionTracker() + ); } @NotNull 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 a3cd0b5369a..aa3fceedb7a 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 @@ -256,13 +256,7 @@ private object KotlinResolveDataProvider { ).getLazyTopDownAnalyzerForTopLevel()!! lazyTopDownAnalyzer.analyzeDeclarations( - TopDownAnalysisParameters.create( - resolveSession.getStorageManager(), - resolveSession.getExceptionTracker(), - /* analyzeCompletely = */ { true }, - /* analyzingBootstrapLibrary = */ false, - /* declaredLocally = */ false - ), + TopDownAnalysisParameters.create(resolveSession.getStorageManager(), resolveSession.getExceptionTracker(), false, false), listOf(analyzableElement) ) return AnalysisResult.success( diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java index ac6f5a4b546..280d6ffa12c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.idea.references; -import com.google.common.base.Predicates; import com.google.common.collect.Sets; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.components.AbstractProjectComponent; @@ -101,9 +100,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( globalContext.getStorageManager(), globalContext.getExceptionTracker(), - Predicates.alwaysFalse(), true, false - ); - + true, false); ModuleDescriptorImpl module = new ModuleDescriptorImpl( Name.special(""), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY ); diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt index 33fa2a0e3a4..85735494b6a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt @@ -66,10 +66,7 @@ class ProjectBasedResolverForDecompiler(project: Project) : ResolverForDecompile module.addDependencyOnModule(module) module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule()) module.seal() - TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext( - project, GlobalContext(), listOf(), BindingTraceContext(), { false }, - module, null, null - ).moduleDescriptor + TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegrationWithCustomContext(project, GlobalContext(), listOf(), BindingTraceContext(), module, null, null).moduleDescriptor } override fun resolveTopLevelClass(classId: ClassId): ClassDescriptor? { diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java index 0d652cdc2b2..bda498d6803 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java @@ -16,8 +16,6 @@ package org.jetbrains.kotlin.idea.highlighter; -import com.google.common.base.Predicates; -import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.analyzer.AnalysisResult; @@ -46,7 +44,7 @@ public abstract class AbstractDiagnosticMessageJsTest extends AbstractDiagnostic @NotNull @Override protected AnalysisResult analyze(@NotNull JetFile file) { - return TopDownAnalyzerFacadeForJS.analyzeFiles(singletonList(file), Predicates.alwaysTrue(), getConfig()); + return TopDownAnalyzerFacadeForJS.analyzeFiles(singletonList(file), getConfig()); } @NotNull 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 1b7d7260f86..871d506ff64 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 @@ -16,13 +16,9 @@ package org.jetbrains.kotlin.js.analyze; -import com.google.common.base.Predicate; -import com.google.common.base.Predicates; import com.google.common.collect.ImmutableList; import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.context.ContextPackage; @@ -53,18 +49,10 @@ public final class TopDownAnalyzerFacadeForJS { private TopDownAnalyzerFacadeForJS() { } - //NOTE: web demo related method - @SuppressWarnings("UnusedDeclaration") - @NotNull - public static BindingContext analyzeFiles(@NotNull Collection files, @NotNull Config config) { - return analyzeFiles(files, Predicates.alwaysTrue(), config).getBindingContext(); - } - //TODO: refactor @NotNull public static JsAnalysisResult analyzeFiles( @NotNull Collection files, - @NotNull Predicate filesToAnalyzeCompletely, @NotNull Config config ) { BindingContext libraryContext = config.getLibraryContext(); @@ -81,7 +69,7 @@ public final class TopDownAnalyzerFacadeForJS { } module.seal(); - return analyzeFilesWithGivenTrace(files, trace, module, filesToAnalyzeCompletely, config); + return analyzeFilesWithGivenTrace(files, trace, module, config); } @NotNull @@ -89,16 +77,13 @@ public final class TopDownAnalyzerFacadeForJS { @NotNull Collection files, @NotNull BindingTrace trace, @NotNull ModuleDescriptorImpl module, - @NotNull Predicate filesToAnalyzeCompletely, @NotNull Config config ) { Project project = config.getProject(); - Predicate completely = Predicates.and(notLibFiles(config.getLibFiles()), filesToAnalyzeCompletely); - GlobalContextImpl globalContext = ContextPackage.GlobalContext(); TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create( - globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false); + globalContext.getStorageManager(), globalContext.getExceptionTracker(), false, false); Collection allFiles = config.getLibraryModule() != null ? files : @@ -108,7 +93,7 @@ public final class TopDownAnalyzerFacadeForJS { project, topDownAnalysisParameters, trace, module, new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), allFiles)); try { - injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, allFiles, + injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, files, Collections.emptyList()); return JsAnalysisResult.success(trace, module); } @@ -124,18 +109,6 @@ public final class TopDownAnalyzerFacadeForJS { } } - @NotNull - private static Predicate notLibFiles(@NotNull final List jsLibFiles) { - return new Predicate() { - @Override - public boolean apply(@Nullable PsiFile file) { - assert file instanceof JetFile; - @SuppressWarnings("UnnecessaryLocalVariable") boolean notLibFile = !jsLibFiles.contains(file); - return notLibFile; - } - }; - } - @NotNull public static ModuleDescriptorImpl createJsModule(@NotNull String name) { return new ModuleDescriptorImpl(Name.special(name), DEFAULT_IMPORTS, PlatformToKotlinClassMap.EMPTY); diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfigWithCaching.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfigWithCaching.java index 7aaade817cd..d16d0375024 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfigWithCaching.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfigWithCaching.java @@ -16,11 +16,9 @@ package org.jetbrains.kotlin.js.config; -import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; import kotlin.Function1; import kotlin.Unit; @@ -123,7 +121,6 @@ public class LibrarySourcesConfigWithCaching extends LibrarySourcesConfig { //noinspection AssignmentToStaticFieldFromInstanceMethod result = TopDownAnalyzerFacadeForJS.analyzeFiles( generateLibFiles(), - Predicates.alwaysFalse(), createConfigWithoutLibFiles(getProject(), getModuleId(), getTarget()) ); } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java index 92e997a73fa..f3d0fdebbc2 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.js.facade; -import com.google.common.base.Predicates; import com.google.dart.compiler.backend.js.ast.JsNode; import com.google.dart.compiler.backend.js.ast.JsProgram; import com.google.dart.compiler.util.TextOutputImpl; @@ -24,7 +23,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VfsUtilCore; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiFile; import com.intellij.util.Consumer; import com.intellij.util.Function; import com.intellij.util.SmartList; @@ -79,7 +77,7 @@ public final class K2JSTranslator { @NotNull List files, @NotNull MainCallParameters mainCallParameters ) throws TranslationException { - JsAnalysisResult analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, Predicates.alwaysTrue(), config); + JsAnalysisResult analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, config); BindingTrace bindingTrace = analysisResult.getBindingTrace(); TopDownAnalyzerFacadeForJS.checkForErrors(Config.withJsLibAdded(files, config), bindingTrace.getBindingContext()); ModuleDescriptor moduleDescriptor = analysisResult.getModuleDescriptor(); diff --git a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt index 9ab64a7804b..0a64622130a 100644 --- a/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt +++ b/libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt @@ -120,7 +120,6 @@ class NoInternalVisibilityInStdLibTest { GlobalContext(), environment.getSourceFiles(), CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), - { true }, module, null, null @@ -136,7 +135,7 @@ class NoInternalVisibilityInStdLibTest { val pathToJsStdlibJar = KOTLIN_ROOT_PATH + PathUtil.getKotlinPathsForDistDirectory().getJsStdLibJarPath().path val config = LibrarySourcesConfig(project, "testModule", listOf(pathToJsStdlibJar), EcmaVersion.defaultVersion(), false, false) - TopDownAnalyzerFacadeForJS.analyzeFiles(listOf(), { true }, config).moduleDescriptor + TopDownAnalyzerFacadeForJS.analyzeFiles(listOf(), config).moduleDescriptor } }