azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

filesToAnalyzeCompletely removed

Browse Source
This commit is contained in:
Andrey Breslav
2015-01-29 19:21:25 +03:00
parent 456bbb6b96
commit bbb59773aa
29 changed files with 33 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java
+1 -3
View File
@@ -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<K2JSCompilerArguments> {
analyzerWithCompilerReport.analyzeAndReport(sources, new Function0<AnalysisResult>() {
@Override
public AnalysisResult invoke() {
return TopDownAnalyzerFacadeForJS.analyzeFiles(sources, Predicates.<PsiFile>alwaysTrue(), config);
return TopDownAnalyzerFacadeForJS.analyzeFiles(sources, config);
}
});
return analyzerWithCompilerReport.hasErrors();
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
-3
View File
@@ -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.<PsiFile>alwaysTrue(),
analyzeModule,
environment.getConfiguration().get(JVMConfigurationKeys.MODULE_IDS),
environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_PROVIDER)
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
-3
View File
@@ -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.<PsiFile>alwaysTrue(),
false,
true
);
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
-4
View File
@@ -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<JetFile> files,
@NotNull BindingTrace trace,
@NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
@NotNull ModuleDescriptorImpl module,
@Nullable List<String> moduleIds,
@Nullable IncrementalCacheProvider incrementalCacheProvider
@@ -96,7 +93,6 @@ public enum TopDownAnalyzerFacadeForJVM {
TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(
globalContext.getStorageManager(),
globalContext.getExceptionTracker(),
filesToAnalyzeCompletely,
false,
false
);
compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisContext.java
+1 -7
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java
+3 -13
View File
@@ -33,26 +33,23 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob
public static TopDownAnalysisParameters create(
@NotNull StorageManager storageManager,
@NotNull ExceptionTracker exceptionTracker,
@NotNull Predicate<PsiFile> 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<PsiFile> 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<PsiFile> 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<PsiFile> 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<PsiFile> getAnalyzeCompletely() {
return analyzeCompletely;
}
public boolean isAnalyzingBootstrapLibrary() {
return analyzingBootstrapLibrary;
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+1 -4
View File
@@ -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(
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTest.java
-3
View File
@@ -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.<PsiFile>alwaysTrue(),
module,
null,
null
compiler/tests/org/jetbrains/kotlin/checkers/AbstractJetDiagnosticsTestWithJsStdLib.java
+1 -3
View File
@@ -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.<PsiFile>alwaysTrue(), config);
TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace(jetFiles, moduleTrace, module, config);
trace.addAllMyDataTo(moduleTrace);
}
compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java
+1 -4
View File
@@ -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.<PsiFile>alwaysTrue()
files.getPsiFiles()
);
analysisResult.throwIfError();
AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());
compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java
+1 -3
View File
@@ -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<JetFile> files) {
AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
project, files, Predicates.<PsiFile>alwaysTrue());
project, files);
return compileFilesGetGenerationState(project, analysisResult, files);
}
compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java
+1 -4
View File
@@ -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.<PsiFile>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.<PsiFile>alwaysTrue()
environment.getProject(), Collections.singleton(jetFile)
);
PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME);
assertNotNull(packageView);
compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java
+1 -3
View File
@@ -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.<PsiFile>alwaysTrue());
jetCoreEnvironment.getProject(), jetFiles);
return new JetFilesAndAnalysisResult(jetFiles, result);
}
compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java
+1 -3
View File
@@ -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.<PsiFile>alwaysTrue());
project, files);
return analysisResult.getBindingContext();
}
compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt
+2 -2
View File
@@ -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));
}
compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
+6 -11
View File
@@ -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.<PsiFile>alwaysTrue());
return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file)
);
}
@NotNull
public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors(
@NotNull Project project,
@NotNull Collection<JetFile> files,
@NotNull Predicate<PsiFile> filesToAnalyzeCompletely
@NotNull Collection<JetFile> 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<JetFile> files,
@NotNull Predicate<PsiFile> filesToAnalyzeCompletely
@NotNull Collection<JetFile> files
) {
ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createJavaModule("<module>");
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);
}
}
compiler/tests/org/jetbrains/kotlin/resolve/lazy/LazyResolveTestUtil.java
-3
View File
@@ -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.<PsiFile>alwaysTrue(),
false, false
);
compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt
+1 -1
View File
@@ -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())
compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java
-9
View File
@@ -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.<PsiFile>alwaysFalse());
}
@NotNull
public static JetCoreEnvironment createEnvironmentWithFullJdk(Disposable disposable) {
return createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(disposable,
compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt
+1 -1
View File
@@ -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
idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java
+2 -4
View File
@@ -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.<PsiFile>alwaysTrue());
resolveSession.getStorageManager(), resolveSession.getExceptionTracker()
);
}
@NotNull
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
+1 -7
View File
@@ -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(
idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java
+1 -4
View File
@@ -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.<PsiFile>alwaysFalse(), true, false
);
true, false);
ModuleDescriptorImpl module = new ModuleDescriptorImpl(
Name.special("<built-ins resolver module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY
);
idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextConsistencyTest.kt
+1 -4
View File
@@ -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? {
idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageJsTest.java
+1 -3
View File
@@ -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.<PsiFile>alwaysTrue(), getConfig());
return TopDownAnalyzerFacadeForJS.analyzeFiles(singletonList(file), getConfig());
}
@NotNull
js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
+3 -30
View File
@@ -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<JetFile> files, @NotNull Config config) {
return analyzeFiles(files, Predicates.<PsiFile>alwaysTrue(), config).getBindingContext();
}
//TODO: refactor
@NotNull
public static JsAnalysisResult analyzeFiles(
@NotNull Collection<JetFile> files,
@NotNull Predicate<PsiFile> 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<JetFile> files,
@NotNull BindingTrace trace,
@NotNull ModuleDescriptorImpl module,
@NotNull Predicate<PsiFile> filesToAnalyzeCompletely,
@NotNull Config config
) {
Project project = config.getProject();
Predicate<PsiFile> 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<JetFile> 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.<PackageFragmentProvider>emptyList());
return JsAnalysisResult.success(trace, module);
}
@@ -124,18 +109,6 @@ public final class TopDownAnalyzerFacadeForJS {
}
}
@NotNull
private static Predicate<PsiFile> notLibFiles(@NotNull final List<JetFile> jsLibFiles) {
return new Predicate<PsiFile>() {
@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);
js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfigWithCaching.java
-3
View File
@@ -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.<PsiFile>alwaysFalse(),
createConfigWithoutLibFiles(getProject(), getModuleId(), getTarget())
);
}
js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java
+1 -3
View File
@@ -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<JetFile> files,
@NotNull MainCallParameters mainCallParameters
) throws TranslationException {
JsAnalysisResult analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, Predicates.<PsiFile>alwaysTrue(), config);
JsAnalysisResult analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(files, config);
BindingTrace bindingTrace = analysisResult.getBindingTrace();
TopDownAnalyzerFacadeForJS.checkForErrors(Config.withJsLibAdded(files, config), bindingTrace.getBindingContext());
ModuleDescriptor moduleDescriptor = analysisResult.getModuleDescriptor();
libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt
+1 -2
View File
@@ -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
}
}