diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java b/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java index 09808b9c3d5..b250bbfe7d7 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/CompilerPluginContext.java @@ -30,7 +30,7 @@ import java.util.List; public class CompilerPluginContext { @NotNull private final Project project; - //TODO: should we in fact store AnalyzeExhaust here? + //TODO: should we in fact store AnalysisResult here? @NotNull private final BindingContext context; @NotNull diff --git a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java index 758dd8e3742..7c0870e3d25 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/common/messages/AnalyzerWithCompilerReport.java @@ -25,7 +25,7 @@ import com.intellij.psi.util.PsiFormatUtil; import kotlin.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.diagnostics.*; @@ -66,7 +66,7 @@ public final class AnalyzerWithCompilerReport { @NotNull private final MessageCollector messageCollectorWrapper; @Nullable - private AnalyzeExhaust analyzeExhaust = null; + private AnalysisResult analysisResult = null; public AnalyzerWithCompilerReport(@NotNull final MessageCollector collector) { messageCollectorWrapper = new MessageCollector() { @@ -99,8 +99,8 @@ public final class AnalyzerWithCompilerReport { } private void reportIncompleteHierarchies() { - assert analyzeExhaust != null; - Collection incompletes = analyzeExhaust.getBindingContext().getKeys(BindingContext.INCOMPLETE_HIERARCHY); + assert analysisResult != null; + Collection incompletes = analysisResult.getBindingContext().getKeys(BindingContext.INCOMPLETE_HIERARCHY); if (!incompletes.isEmpty()) { StringBuilder message = new StringBuilder("The following classes have incomplete hierarchies:\n"); for (ClassDescriptor incomplete : incompletes) { @@ -112,8 +112,8 @@ public final class AnalyzerWithCompilerReport { } private void reportAlternativeSignatureErrors() { - assert analyzeExhaust != null; - BindingContext bc = analyzeExhaust.getBindingContext(); + assert analysisResult != null; + BindingContext bc = analysisResult.getBindingContext(); Collection descriptorsWithErrors = bc.getKeys(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS); if (!descriptorsWithErrors.isEmpty()) { StringBuilder message = new StringBuilder("The following Java entities have annotations with wrong Kotlin signatures:\n"); @@ -137,8 +137,8 @@ public final class AnalyzerWithCompilerReport { } private void reportAbiVersionErrors() { - assert analyzeExhaust != null; - BindingContext bindingContext = analyzeExhaust.getBindingContext(); + assert analysisResult != null; + BindingContext bindingContext = analysisResult.getBindingContext(); Collection errorClasses = bindingContext.getKeys(TraceBasedErrorReporter.ABI_VERSION_ERRORS); for (VirtualFileKotlinClass kotlinClass : errorClasses) { @@ -212,20 +212,20 @@ public final class AnalyzerWithCompilerReport { } @Nullable - public AnalyzeExhaust getAnalyzeExhaust() { - return analyzeExhaust; + public AnalysisResult getAnalysisResult() { + return analysisResult; } public boolean hasErrors() { return hasErrors; } - public void analyzeAndReport(@NotNull Collection files, @NotNull Function0 analyzer) { - analyzeExhaust = analyzer.invoke(); + public void analyzeAndReport(@NotNull Collection files, @NotNull Function0 analyzer) { + analysisResult = analyzer.invoke(); reportAbiVersionErrors(); reportSyntaxErrors(files); //noinspection ConstantConditions - reportDiagnostics(analyzeExhaust.getBindingContext().getDiagnostics(), messageCollectorWrapper); + reportDiagnostics(analysisResult.getBindingContext().getDiagnostics(), messageCollectorWrapper); reportIncompleteHierarchies(); reportAlternativeSignatureErrors(); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java index 7dcd72f5f2e..39fe8e75b96 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/js/K2JSCompiler.java @@ -33,7 +33,7 @@ import kotlin.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.OutputFileCollection; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.common.CLICompiler; import org.jetbrains.jet.cli.common.CLIConfigurationKeys; import org.jetbrains.jet.cli.common.ExitCode; @@ -198,9 +198,9 @@ public class K2JSCompiler extends CLICompiler { private static boolean analyzeAndReportErrors(@NotNull MessageCollector messageCollector, @NotNull final List sources, @NotNull final Config config) { AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport(messageCollector); - analyzerWithCompilerReport.analyzeAndReport(sources, new Function0() { + analyzerWithCompilerReport.analyzeAndReport(sources, new Function0() { @Override - public AnalyzeExhaust invoke() { + public AnalysisResult invoke() { return TopDownAnalyzerFacadeForJS.analyzeFiles(sources, Predicates.alwaysTrue(), config); } }); diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index 24023f41b0a..a9ad9b30f58 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -30,7 +30,7 @@ import kotlin.modules.AllModules; import kotlin.modules.Module; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.asJava.FilteredJvmDiagnostics; import org.jetbrains.jet.cli.common.CLIConfigurationKeys; import org.jetbrains.jet.cli.common.CompilerPlugin; @@ -41,7 +41,6 @@ import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.codegen.*; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.Progress; -import org.jetbrains.jet.config.CommonConfigurationKeys; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.parsing.JetScriptDefinition; @@ -117,12 +116,12 @@ public class KotlinToJVMBytecodeCompiler { try { environment = JetCoreEnvironment.createForProduction(parentDisposable, compilerConfiguration); - AnalyzeExhaust exhaust = analyze(environment); - if (exhaust == null) { + AnalysisResult result = analyze(environment); + if (result == null) { return false; } - exhaust.throwIfError(); + result.throwIfError(); for (Module module : chunk) { List jetFiles = CompileEnvironmentUtil.getJetFiles( @@ -134,7 +133,7 @@ public class KotlinToJVMBytecodeCompiler { } ); GenerationState generationState = - generate(environment, exhaust, jetFiles, module.getModuleName(), new File(module.getOutputDirectory())); + generate(environment, result, jetFiles, module.getModuleName(), new File(module.getOutputDirectory())); outputFiles.put(module, generationState.getFactory()); } } @@ -270,26 +269,26 @@ public class KotlinToJVMBytecodeCompiler { @Nullable public static GenerationState analyzeAndGenerate(@NotNull JetCoreEnvironment environment) { - AnalyzeExhaust exhaust = analyze(environment); + AnalysisResult result = analyze(environment); - if (exhaust == null) { + if (result == null) { return null; } - exhaust.throwIfError(); + result.throwIfError(); - return generate(environment, exhaust, environment.getSourceFiles(), null, null); + return generate(environment, result, environment.getSourceFiles(), null, null); } @Nullable - private static AnalyzeExhaust analyze(@NotNull final JetCoreEnvironment environment) { + private static AnalysisResult analyze(@NotNull final JetCoreEnvironment environment) { AnalyzerWithCompilerReport analyzerWithCompilerReport = new AnalyzerWithCompilerReport( environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)); analyzerWithCompilerReport.analyzeAndReport( - environment.getSourceFiles(), new Function0() { + environment.getSourceFiles(), new Function0() { @NotNull @Override - public AnalyzeExhaust invoke() { + public AnalysisResult invoke() { CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject()); BindingTrace sharedTrace = support.getTrace(); ModuleDescriptorImpl sharedModule = support.newModule(); @@ -307,22 +306,22 @@ public class KotlinToJVMBytecodeCompiler { } ); - AnalyzeExhaust exhaust = analyzerWithCompilerReport.getAnalyzeExhaust(); - assert exhaust != null : "AnalyzeExhaust should be non-null, compiling: " + environment.getSourceFiles(); + AnalysisResult result = analyzerWithCompilerReport.getAnalysisResult(); + assert result != null : "AnalysisResult should be non-null, compiling: " + environment.getSourceFiles(); - CompilerPluginContext context = new CompilerPluginContext(environment.getProject(), exhaust.getBindingContext(), + CompilerPluginContext context = new CompilerPluginContext(environment.getProject(), result.getBindingContext(), environment.getSourceFiles()); for (CompilerPlugin plugin : environment.getConfiguration().getList(CLIConfigurationKeys.COMPILER_PLUGINS)) { plugin.processFiles(context); } - return analyzerWithCompilerReport.hasErrors() ? null : exhaust; + return analyzerWithCompilerReport.hasErrors() ? null : result; } @NotNull private static GenerationState generate( @NotNull JetCoreEnvironment environment, - @NotNull AnalyzeExhaust exhaust, + @NotNull AnalysisResult result, @NotNull List sourceFiles, @Nullable String moduleId, File outputDirectory @@ -343,8 +342,8 @@ public class KotlinToJVMBytecodeCompiler { environment.getProject(), ClassBuilderFactories.BINARIES, Progress.DEAF, - exhaust.getModuleDescriptor(), - exhaust.getBindingContext(), + result.getModuleDescriptor(), + result.getBindingContext(), sourceFiles, configuration.get(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false), configuration.get(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false), @@ -360,7 +359,7 @@ public class KotlinToJVMBytecodeCompiler { AnalyzerWithCompilerReport.reportDiagnostics( new FilteredJvmDiagnostics( diagnosticHolder.getBindingContext().getDiagnostics(), - exhaust.getBindingContext().getDiagnostics() + result.getBindingContext().getDiagnostics() ), environment.getConfiguration().get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) ); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java index 9c8b75c60b1..a56bca4f713 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TopDownAnalyzerFacadeForJVM.java @@ -22,7 +22,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.context.ContextPackage; import org.jetbrains.jet.context.GlobalContext; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; @@ -57,7 +57,7 @@ public enum TopDownAnalyzerFacadeForJVM { } @NotNull - public static AnalyzeExhaust analyzeFilesWithJavaIntegration( + public static AnalysisResult analyzeFilesWithJavaIntegration( Project project, Collection files, BindingTrace trace, @@ -72,7 +72,7 @@ public enum TopDownAnalyzerFacadeForJVM { incrementalCacheProvider); } - public static AnalyzeExhaust analyzeFilesWithJavaIntegrationWithCustomContext( + public static AnalysisResult analyzeFilesWithJavaIntegrationWithCustomContext( @NotNull Project project, @NotNull GlobalContext globalContext, @NotNull Collection files, @@ -109,7 +109,7 @@ public enum TopDownAnalyzerFacadeForJVM { additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider()); injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders); - return AnalyzeExhaust.success(trace.getBindingContext(), module); + return AnalysisResult.success(trace.getBindingContext(), module); } finally { injector.destroy(); diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.kt b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalysisResult.kt similarity index 79% rename from compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.kt rename to compiler/frontend/src/org/jetbrains/jet/analyzer/AnalysisResult.kt index 730508956a0..b3d5e50e57b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.kt +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalysisResult.kt @@ -21,13 +21,13 @@ import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.types.ErrorUtils import kotlin.platform.platformStatic -public data open class AnalyzeExhaust protected ( +public data open class AnalysisResult protected ( public val bindingContext: BindingContext, public val moduleDescriptor: ModuleDescriptor ) { public val error: Throwable - get() = if (this is Error) this.exception else throw IllegalStateException("Should only be called for error analyze exhaust") + get() = if (this is Error) this.exception else throw IllegalStateException("Should only be called for error analysis result") public fun isError(): Boolean = this is Error @@ -37,16 +37,16 @@ public data open class AnalyzeExhaust protected ( } } - private class Error(bindingContext: BindingContext, val exception: Throwable) : AnalyzeExhaust(bindingContext, ErrorUtils.getErrorModule()) + private class Error(bindingContext: BindingContext, val exception: Throwable) : AnalysisResult(bindingContext, ErrorUtils.getErrorModule()) class object { - public val EMPTY: AnalyzeExhaust = success(BindingContext.EMPTY, ErrorUtils.getErrorModule()) + public val EMPTY: AnalysisResult = success(BindingContext.EMPTY, ErrorUtils.getErrorModule()) - platformStatic public fun success(bindingContext: BindingContext, module: ModuleDescriptor): AnalyzeExhaust { - return AnalyzeExhaust(bindingContext, module) + platformStatic public fun success(bindingContext: BindingContext, module: ModuleDescriptor): AnalysisResult { + return AnalysisResult(bindingContext, module) } - platformStatic public fun error(bindingContext: BindingContext, error: Throwable): AnalyzeExhaust { + platformStatic public fun error(bindingContext: BindingContext, error: Throwable): AnalysisResult { return Error(bindingContext, error) } } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index a7eeb56cb5c..095322f77d5 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -47,7 +47,7 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; @@ -93,7 +93,7 @@ import static org.jetbrains.jet.ConfigurationKind.ALL; import static org.jetbrains.jet.ConfigurationKind.JDK_AND_ANNOTATIONS; import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY; import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY; -import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalyzeExhaust; +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult; import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory; public class JetTestUtils { @@ -244,12 +244,12 @@ public class JetTestUtils { } @NotNull - public static AnalyzeExhaust analyzeFile(@NotNull JetFile file) { + public static AnalysisResult analyzeFile(@NotNull JetFile file) { return JvmResolveUtil.analyzeOneFileWithJavaIntegration(file); } @NotNull - public static AnalyzeExhaust analyzeFileWithoutBody(@NotNull JetFile file) { + public static AnalysisResult analyzeFileWithoutBody(@NotNull JetFile file) { return JvmResolveUtil.analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), Predicates.alwaysFalse()); @@ -486,7 +486,7 @@ public class JetTestUtils { @NotNull Disposable disposable ) throws IOException { if (!ktFiles.isEmpty()) { - compileKotlinToDirAndGetAnalyzeExhaust(ktFiles, outDir, disposable, ALL); + compileKotlinToDirAndGetAnalysisResult(ktFiles, outDir, disposable, ALL); } else { boolean mkdirs = outDir.mkdirs(); diff --git a/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudocodeTest.java b/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudocodeTest.java index 5f3aadd3fad..79dbf4f2ed3 100644 --- a/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudocodeTest.java +++ b/compiler/tests/org/jetbrains/jet/cfg/AbstractPseudocodeTest.java @@ -23,7 +23,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.cfg.pseudocode.Pseudocode; import org.jetbrains.jet.lang.cfg.pseudocode.PseudocodeImpl; @@ -54,9 +54,9 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment { JetFile jetFile = JetTestUtils.loadJetFile(getProject(), file); Map data = new LinkedHashMap(); - AnalyzeExhaust analyzeExhaust = JetTestUtils.analyzeFile(jetFile); + AnalysisResult analysisResult = JetTestUtils.analyzeFile(jetFile); List declarations = jetFile.getDeclarations(); - BindingContext bindingContext = analyzeExhaust.getBindingContext(); + BindingContext bindingContext = analysisResult.getBindingContext(); for (JetDeclaration declaration : declarations) { addDeclaration(data, bindingContext, declaration); diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java index 543dc2c3b0a..c7fa919cf5d 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java @@ -24,7 +24,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; @@ -52,18 +52,18 @@ public class CodegenTestUtil { @NotNull public static ClassFileFactory generateFiles(@NotNull JetCoreEnvironment environment, @NotNull CodegenTestFiles files) { - AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( + AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( environment.getProject(), files.getPsiFiles(), Predicates.alwaysTrue() ); - analyzeExhaust.throwIfError(); - AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); + analysisResult.throwIfError(); + AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); CompilerConfiguration configuration = environment.getConfiguration(); BindingTraceContext forExtraDiagnostics = new BindingTraceContext(); GenerationState state = new GenerationState( environment.getProject(), ClassBuilderFactories.TEST, Progress.DEAF, - analyzeExhaust.getModuleDescriptor(), analyzeExhaust.getBindingContext(), files.getPsiFiles(), + analysisResult.getModuleDescriptor(), analysisResult.getBindingContext(), files.getPsiFiles(), configuration.get(JVMConfigurationKeys.DISABLE_CALL_ASSERTIONS, false), configuration.get(JVMConfigurationKeys.DISABLE_PARAM_ASSERTIONS, false), GenerationState.GenerateClassFilter.GENERATE_ALL, diff --git a/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java index 7ae0518a0b7..d87a7ac6a4e 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java @@ -20,7 +20,7 @@ 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.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil; @@ -40,26 +40,26 @@ public class GenerationUtils { @NotNull public static GenerationState compileFileGetGenerationStateForTest(@NotNull JetFile psiFile) { - AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile); - return compileFilesGetGenerationState(psiFile.getProject(), analyzeExhaust, Collections.singletonList(psiFile)); + AnalysisResult analysisResult = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile); + return compileFilesGetGenerationState(psiFile.getProject(), analysisResult, Collections.singletonList(psiFile)); } @NotNull public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List files) { - AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( + AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( project, files, Predicates.alwaysTrue()); - return compileFilesGetGenerationState(project, analyzeExhaust, files); + return compileFilesGetGenerationState(project, analysisResult, files); } @NotNull public static GenerationState compileFilesGetGenerationState( @NotNull Project project, - @NotNull AnalyzeExhaust analyzeExhaust, + @NotNull AnalysisResult analysisResult, @NotNull List files ) { - analyzeExhaust.throwIfError(); - GenerationState state = new GenerationState(project, ClassBuilderFactories.TEST, analyzeExhaust.getModuleDescriptor(), - analyzeExhaust.getBindingContext(), files); + analysisResult.throwIfError(); + GenerationState state = new GenerationState(project, ClassBuilderFactories.TEST, analysisResult.getModuleDescriptor(), + analysisResult.getBindingContext(), files); KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION); return state; } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index 9ac4e1c91b7..3986703e010 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; @@ -80,7 +80,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { File sourcesDir = new File(expectedFileName.replaceFirst("\\.txt$", "")); List kotlinSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.kt"), sourcesDir); - compileKotlinToDirAndGetAnalyzeExhaust(kotlinSources, tmpdir, myTestRootDisposable, ConfigurationKind.JDK_ONLY); + compileKotlinToDirAndGetAnalysisResult(kotlinSources, tmpdir, myTestRootDisposable, ConfigurationKind.JDK_ONLY); List javaSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.java"), sourcesDir); Pair binaryPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary( @@ -104,10 +104,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { protected void doTestCompiledKotlin(@NotNull String ktFileName, @NotNull ConfigurationKind configurationKind) throws Exception { File ktFile = new File(ktFileName); File txtFile = new File(ktFileName.replaceFirst("\\.kt$", ".txt")); - AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(Collections.singletonList(ktFile), tmpdir, getTestRootDisposable(), + AnalysisResult result = compileKotlinToDirAndGetAnalysisResult(Collections.singletonList(ktFile), tmpdir, getTestRootDisposable(), configurationKind); - PackageViewDescriptor packageFromSource = exhaust.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); + PackageViewDescriptor packageFromSource = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); assert packageFromSource != null : "Package " + TEST_PACKAGE_FQNAME + " not found"; Assert.assertEquals("test", packageFromSource.getName().asString()); @@ -194,10 +194,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { ); JetFile jetFile = JetTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); - AnalyzeExhaust exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( + AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( environment.getProject(), Collections.singleton(jetFile), Predicates.alwaysTrue() ); - PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); + PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); assertNotNull(packageView); validateAndCompareDescriptorWithFile(packageView, DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy( diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java index 3b70b326cb8..02db3bd8102 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java @@ -24,7 +24,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.MockLibraryUtil; import org.jetbrains.jet.TestJdkKind; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.jet.cli.common.messages.MessageCollectorPlainTextToStream; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; @@ -82,11 +82,11 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { private PackageViewDescriptor analyzeFileToPackageView(@NotNull File... extraClassPath) throws IOException { Project project = createEnvironment(Arrays.asList(extraClassPath)).getProject(); - AnalyzeExhaust exhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors( + AnalysisResult result = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors( JetTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt")) ); - PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME); + PackageViewDescriptor packageView = result.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME); assertNotNull("Failed to find package: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView); return packageView; } @@ -174,12 +174,12 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { Project project = createEnvironment(Collections.singletonList(tmpdir)).getProject(); - AnalyzeExhaust exhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration( + AnalysisResult result = JvmResolveUtil.analyzeOneFileWithJavaIntegration( JetTestUtils.loadJetFile(project, getTestDataFileWithExtension("kt")) ); - exhaust.throwIfError(); + result.throwIfError(); - BindingContext bindingContext = exhaust.getBindingContext(); + BindingContext bindingContext = result.getBindingContext(); AnalyzerWithCompilerReport.reportDiagnostics(bindingContext.getDiagnostics(), MessageCollectorPlainTextToStream.PLAIN_TEXT_TO_SYSTEM_ERR); assertEquals("There should be no diagnostics", 0, Iterables.size(bindingContext.getDiagnostics())); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index d0ec8abe8ff..b42b3efb3a5 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -27,7 +27,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; @@ -45,13 +45,11 @@ import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.io.File; import java.io.IOException; import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.List; import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations; @@ -65,18 +63,18 @@ public final class LoadDescriptorUtil { } @NotNull - public static AnalyzeExhaust compileKotlinToDirAndGetAnalyzeExhaust( + public static AnalysisResult compileKotlinToDirAndGetAnalysisResult( @NotNull List kotlinFiles, @NotNull File outDir, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind ) { - JetFilesAndExhaust fileAndExhaust = JetFilesAndExhaust.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind); - AnalyzeExhaust exhaust = fileAndExhaust.getExhaust(); - List files = fileAndExhaust.getJetFiles(); - GenerationState state = GenerationUtils.compileFilesGetGenerationState(files.get(0).getProject(), exhaust, files); + JetFilesAndAnalysisResult filesAndResult = JetFilesAndAnalysisResult.createJetFilesAndAnalyze(kotlinFiles, disposable, configurationKind); + AnalysisResult result = filesAndResult.getAnalysisResult(); + List files = filesAndResult.getJetFiles(); + GenerationState state = GenerationUtils.compileFilesGetGenerationState(files.get(0).getProject(), result, files); OutputUtilsPackage.writeAllTo(state.getFactory(), outDir); - return exhaust; + return result; } @NotNull @@ -126,9 +124,9 @@ public final class LoadDescriptorUtil { )); } - private static class JetFilesAndExhaust { + private static class JetFilesAndAnalysisResult { @NotNull - public static JetFilesAndExhaust createJetFilesAndAnalyze( + public static JetFilesAndAnalysisResult createJetFilesAndAnalyze( @NotNull List kotlinFiles, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind @@ -146,17 +144,17 @@ public final class LoadDescriptorUtil { } } }); - AnalyzeExhaust exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( + AnalysisResult result = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors( jetCoreEnvironment.getProject(), jetFiles, Predicates.alwaysTrue()); - return new JetFilesAndExhaust(jetFiles, exhaust); + return new JetFilesAndAnalysisResult(jetFiles, result); } private final List jetFiles; - private final AnalyzeExhaust exhaust; + private final AnalysisResult result; - private JetFilesAndExhaust(@NotNull List jetFiles, @NotNull AnalyzeExhaust exhaust) { + private JetFilesAndAnalysisResult(@NotNull List jetFiles, @NotNull AnalysisResult result) { this.jetFiles = jetFiles; - this.exhaust = exhaust; + this.result = result; } @NotNull @@ -165,8 +163,8 @@ public final class LoadDescriptorUtil { } @NotNull - public AnalyzeExhaust getExhaust() { - return exhaust; + public AnalysisResult getAnalysisResult() { + return result; } } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java index 6422ea1b3c2..11246036493 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java @@ -21,7 +21,7 @@ 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.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; @@ -35,24 +35,24 @@ import java.util.Collections; public class JvmResolveUtil { @NotNull - public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file) { + public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file) { AnalyzingUtils.checkForSyntacticErrors(file); - AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file); + AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file); - AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); + AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); - return analyzeExhaust; + return analysisResult; } @NotNull - public static AnalyzeExhaust analyzeOneFileWithJavaIntegration(@NotNull JetFile file) { + public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) { return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), Predicates.alwaysTrue()); } @NotNull - public static AnalyzeExhaust analyzeFilesWithJavaIntegrationAndCheckForErrors( + public static AnalysisResult analyzeFilesWithJavaIntegrationAndCheckForErrors( @NotNull Project project, @NotNull Collection files, @NotNull Predicate filesToAnalyzeCompletely @@ -61,15 +61,15 @@ public class JvmResolveUtil { AnalyzingUtils.checkForSyntacticErrors(file); } - AnalyzeExhaust analyzeExhaust = analyzeFilesWithJavaIntegration(project, files, filesToAnalyzeCompletely); + AnalysisResult analysisResult = analyzeFilesWithJavaIntegration(project, files, filesToAnalyzeCompletely); - AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext()); + AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext()); - return analyzeExhaust; + return analysisResult; } @NotNull - public static AnalyzeExhaust analyzeFilesWithJavaIntegration( + public static AnalysisResult analyzeFilesWithJavaIntegration( @NotNull Project project, @NotNull Collection files, @NotNull Predicate filesToAnalyzeCompletely diff --git a/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java index 3352f781de7..36a470c35ef 100644 --- a/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java @@ -23,7 +23,7 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestCaseBuilder; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; @@ -94,14 +94,14 @@ public class DescriptorRendererTest extends JetLiteFixture { private void doTest() throws IOException { String fileName = getTestName(false) + ".kt"; JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName)); - AnalyzeExhaust analyzeExhaust = + AnalysisResult analysisResult = JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile); - final BindingContext bindingContext = analyzeExhaust.getBindingContext(); + final BindingContext bindingContext = analysisResult.getBindingContext(); final List descriptors = new ArrayList(); FqName fqName = psiFile.getPackageFqName(); if (!fqName.isRoot()) { - PackageViewDescriptor packageDescriptor = analyzeExhaust.getModuleDescriptor().getPackage(fqName); + PackageViewDescriptor packageDescriptor = analysisResult.getModuleDescriptor().getPackage(fqName); descriptors.add(packageDescriptor); } diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 398b0046c46..72b81c9d358 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -26,7 +26,7 @@ import com.intellij.psi.PsiQualifiedNamedElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; @@ -142,9 +142,9 @@ public abstract class ExpectedResolveData { } Project project = files.iterator().next().getProject(); - AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration( + AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration( project, files, Predicates.alwaysTrue()); - return analyzeExhaust.getBindingContext(); + return analysisResult.getBindingContext(); } public final void checkResult(BindingContext bindingContext) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index ccb96e924b7..aecf2c1e22d 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java @@ -23,7 +23,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -317,8 +317,8 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix @NotNull protected JetFile getFile(@NotNull String content) { JetFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject()); - AnalyzeExhaust analyzeExhaust = analyzeFile(ktFile); - context = analyzeExhaust.getBindingContext(); + AnalysisResult analysisResult = analyzeFile(ktFile); + context = analysisResult.getBindingContext(); return ktFile; } @@ -336,7 +336,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix } @NotNull - protected AnalyzeExhaust analyzeFile(@NotNull JetFile ktFile) { + protected AnalysisResult analyzeFile(@NotNull JetFile ktFile) { return JetTestUtils.analyzeFile(ktFile); } diff --git a/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt b/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt index 73dacba9a65..b3512511f52 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt @@ -16,7 +16,7 @@ package org.jetbrains.jet.resolve.annotation -import org.jetbrains.jet.analyzer.AnalyzeExhaust +import org.jetbrains.jet.analyzer.AnalysisResult import org.jetbrains.jet.lang.psi.JetFile import org.jetbrains.jet.JetTestUtils @@ -26,5 +26,5 @@ class AnnotationDescriptorResolveWithoutAnalyzeBodyTest : AnnotationDescriptorRe checkAnnotationOnAllExceptLocalDeclarations(content, expectedAnnotation) } - override fun analyzeFile(ktFile: JetFile): AnalyzeExhaust = JetTestUtils.analyzeFileWithoutBody(ktFile) + override fun analyzeFile(ktFile: JetFile): AnalysisResult = JetTestUtils.analyzeFileWithoutBody(ktFile) } \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java index 3c6c7cea64f..67f4fcabca2 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java +++ b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java @@ -19,7 +19,7 @@ package org.jetbrains.jet.test.util; import com.google.common.collect.Lists; import com.intellij.openapi.util.io.FileUtil; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFile; @@ -43,8 +43,8 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment File txtFile = new File("compiler/testData/recursiveProcessor/declarations.txt"); String text = FileUtil.loadFile(ktFile, true); JetFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject()); - AnalyzeExhaust exhaust = JetTestUtils.analyzeFile(jetFile); - PackageViewDescriptor testPackage = exhaust.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test"))); + AnalysisResult result = JetTestUtils.analyzeFile(jetFile); + PackageViewDescriptor testPackage = result.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test"))); assert testPackage != null; List descriptors = recursivelyCollectDescriptors(testPackage); diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 68be1347eef..9cc51e650c2 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -21,7 +21,7 @@ import com.intellij.psi.PsiFile; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.*; @@ -86,7 +86,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = file.getDeclarations(); JetDeclaration aClass = declarations.get(0); assert aClass instanceof JetClass; - AnalyzeExhaust bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(file); + AnalysisResult bindingContext = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(file); DeclarationDescriptor classDescriptor = bindingContext.getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, aClass); WritableScopeImpl scope = new WritableScopeImpl( libraryScope, root, RedeclarationHandler.DO_NOTHING, "JetDefaultModalityModifiersTest"); diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt index 71483718965..f9c402cdd0c 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt @@ -19,7 +19,7 @@ package org.jetbrains.jet.plugin.caches.resolve import org.jetbrains.jet.lang.psi.JetElement import org.jetbrains.jet.lang.psi.JetFile import com.intellij.openapi.project.Project -import org.jetbrains.jet.analyzer.AnalyzeExhaust +import org.jetbrains.jet.analyzer.AnalysisResult import com.intellij.openapi.diagnostic.Logger import com.intellij.util.containers.SLRUCache import com.intellij.psi.util.PsiModificationTracker @@ -172,7 +172,7 @@ public class KotlinCacheService(val project: Project) { return getCacheToAnalyzeFiles(listOf(file)).getLazyResolveSession(file) } - public fun getAnalysisResults(elements: Collection): AnalyzeExhaust { + public fun getAnalysisResults(elements: Collection): AnalysisResult { val files = elements.map { it.getContainingJetFile() }.toSet() assertAreInSameModule(files) diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt index 596d7e54a61..ab82259de3f 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt @@ -20,7 +20,7 @@ import org.jetbrains.jet.lang.psi.JetElement import org.jetbrains.jet.lang.psi.JetFile import com.intellij.psi.util.PsiTreeUtil import com.intellij.openapi.project.Project -import org.jetbrains.jet.analyzer.AnalyzeExhaust +import org.jetbrains.jet.analyzer.AnalysisResult import com.intellij.psi.util.CachedValuesManager import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils import com.intellij.util.containers.SLRUCache @@ -100,7 +100,7 @@ private class KotlinResolveCache( CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker) }, false) - fun getAnalysisResultsForElements(elements: Collection): AnalyzeExhaust { + fun getAnalysisResultsForElements(elements: Collection): AnalysisResult { val slruCache = synchronized(analysisResults) { analysisResults.getValue()!! } @@ -113,24 +113,24 @@ private class KotlinResolveCache( val withError = results.firstOrNull { it.isError() } val bindingContext = CompositeBindingContext.create(results.map { it.bindingContext }) return if (withError != null) - AnalyzeExhaust.error(bindingContext, withError.error) + AnalysisResult.error(bindingContext, withError.error) else //TODO: (module refactoring) several elements are passed here in debugger - AnalyzeExhaust.success(bindingContext, getLazyResolveSession(elements.first()).getModuleDescriptor()) + AnalysisResult.success(bindingContext, getLazyResolveSession(elements.first()).getModuleDescriptor()) } } private class PerFileAnalysisCache(val file: JetFile, val resolveSession: ResolveSessionForBodies) { - private val cache = HashMap() + private val cache = HashMap() - private fun lookUp(analyzableElement: JetElement): AnalyzeExhaust? { + private fun lookUp(analyzableElement: JetElement): AnalysisResult? { // Looking for parent elements that are already analyzed // Also removing all elements whose parents are already analyzed, to guarantee consistency val descendantsOfCurrent = arrayListOf() val toRemove = hashSetOf() var current: PsiElement? = analyzableElement - var result: AnalyzeExhaust? = null + var result: AnalysisResult? = null while (current != null) { val cached = cache[current] if (cached != null) { @@ -148,12 +148,12 @@ private class PerFileAnalysisCache(val file: JetFile, val resolveSession: Resolv return result } - fun getAnalysisResults(element: JetElement): AnalyzeExhaust { + fun getAnalysisResults(element: JetElement): AnalysisResult { assert (element.getContainingJetFile() == file, "Wrong file. Expected $file, but was ${element.getContainingJetFile()}") val analyzableParent = KotlinResolveDataProvider.findAnalyzableParent(element) - return synchronized(this) { (): AnalyzeExhaust -> + return synchronized(this) { (): AnalysisResult -> val cached = lookUp(analyzableParent) if (cached != null) return@synchronized cached @@ -166,10 +166,10 @@ private class PerFileAnalysisCache(val file: JetFile, val resolveSession: Resolv } } - private fun analyze(analyzableElement: JetElement): AnalyzeExhaust { + private fun analyze(analyzableElement: JetElement): AnalysisResult { val project = analyzableElement.getProject() if (DumbService.isDumb(project)) { - return AnalyzeExhaust.EMPTY + return AnalysisResult.EMPTY } try { @@ -182,7 +182,7 @@ private class PerFileAnalysisCache(val file: JetFile, val resolveSession: Resolv DiagnosticUtils.throwIfRunningOnServer(e) LOG.error(e) - return AnalyzeExhaust.error(BindingContext.EMPTY, e) + return AnalysisResult.error(BindingContext.EMPTY, e) } } } @@ -222,10 +222,10 @@ private object KotlinResolveDataProvider { ?: element.getContainingJetFile() } - fun analyze(project: Project, resolveSession: ResolveSessionForBodies, analyzableElement: JetElement): AnalyzeExhaust { + fun analyze(project: Project, resolveSession: ResolveSessionForBodies, analyzableElement: JetElement): AnalysisResult { try { if (analyzableElement is JetCodeFragment) { - return AnalyzeExhaust.success( + return AnalysisResult.success( analyzeExpressionCodeFragment(resolveSession, analyzableElement), resolveSession.getModuleDescriptor() ) @@ -259,7 +259,7 @@ private object KotlinResolveDataProvider { ), listOf(analyzableElement) ) - return AnalyzeExhaust.success( + return AnalysisResult.success( trace.getBindingContext(), resolveSession.getModuleDescriptor() ) @@ -271,7 +271,7 @@ private object KotlinResolveDataProvider { DiagnosticUtils.throwIfRunningOnServer(e) LOG.error(e) - return AnalyzeExhaust.error(BindingContext.EMPTY, e) + return AnalysisResult.error(BindingContext.EMPTY, e) } } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/resolutionApi.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/resolutionApi.kt index d9c9be97af5..0ef677dde52 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/resolutionApi.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/resolutionApi.kt @@ -18,7 +18,7 @@ package org.jetbrains.jet.plugin.caches.resolve import org.jetbrains.jet.lang.psi.JetElement import org.jetbrains.jet.lang.psi.JetFile -import org.jetbrains.jet.analyzer.AnalyzeExhaust +import org.jetbrains.jet.analyzer.AnalysisResult import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lang.psi.JetDeclaration import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor @@ -28,7 +28,7 @@ public fun JetElement.getLazyResolveSession(): ResolutionFacade { return KotlinCacheService.getInstance(getProject()).getResolutionFacade(listOf(this)) } -public fun JetElement.getAnalysisResults(vararg extraFiles: JetFile): AnalyzeExhaust { +public fun JetElement.getAnalysisResults(vararg extraFiles: JetFile): AnalysisResult { return KotlinCacheService.getInstance(getProject()).getAnalysisResults(listOf(this) + extraFiles.toList()) } @@ -48,8 +48,8 @@ public fun JetElement.getBindingContext(): BindingContext { return getAnalysisResults().bindingContext } -public fun getAnalysisResultsForElements(elements: Collection): AnalyzeExhaust { - if (elements.isEmpty()) return AnalyzeExhaust.EMPTY +public fun getAnalysisResultsForElements(elements: Collection): AnalysisResult { + if (elements.isEmpty()) return AnalysisResult.EMPTY val element = elements.first() return KotlinCacheService.getInstance(element.getProject()).getAnalysisResults(elements) } \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java index 7530b8aeb64..f9905bf396a 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/JetPsiChecker.java @@ -35,7 +35,7 @@ import com.intellij.xml.util.XmlStringUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.diagnostics.Severity; @@ -101,12 +101,12 @@ public class JetPsiChecker implements Annotator, HighlightRangeExtension { JetFile file = (JetFile) element.getContainingFile(); - AnalyzeExhaust analyzeExhaust = ResolvePackage.getAnalysisResults(file); - if (analyzeExhaust.isError()) { - throw new ProcessCanceledException(analyzeExhaust.getError()); + AnalysisResult analysisResult = ResolvePackage.getAnalysisResults(file); + if (analysisResult.isError()) { + throw new ProcessCanceledException(analysisResult.getError()); } - BindingContext bindingContext = analyzeExhaust.getBindingContext(); + BindingContext bindingContext = analysisResult.getBindingContext(); for (HighlightingVisitor visitor : getAfterAnalysisVisitor(holder, bindingContext)) { element.accept(visitor); diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java index a9beb8ad772..9039633a156 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java +++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java @@ -38,7 +38,7 @@ import com.sun.jdi.request.ClassPrepareRequest; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.codegen.AsmUtil; import org.jetbrains.jet.codegen.ClassBuilderFactories; import org.jetbrains.jet.codegen.state.GenerationState; @@ -326,11 +326,11 @@ public class JetPositionManager implements PositionManager { GlobalSearchScope packageFacadeScope = key.second.contentScope(); Collection packageFiles = findFilesWithExactPackage(key.first, packageFacadeScope, project); - AnalyzeExhaust analyzeExhaust = ResolvePackage.getAnalysisResultsForElements(packageFiles); - analyzeExhaust.throwIfError(); + AnalysisResult analysisResult = ResolvePackage.getAnalysisResultsForElements(packageFiles); + analysisResult.throwIfError(); GenerationState state = new GenerationState(project, ClassBuilderFactories.THROW_EXCEPTION, - analyzeExhaust.getModuleDescriptor(), analyzeExhaust.getBindingContext(), + analysisResult.getModuleDescriptor(), analysisResult.getBindingContext(), new ArrayList(packageFiles) ); state.beforeCompile(); diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt b/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt index db1dd5f245e..f76c6153ece 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt +++ b/idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt @@ -280,17 +280,17 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment, throw EvaluateExceptionUtil.createEvaluateException(e.getMessage()) } - val analyzeExhaust = this.getAnalysisResults(createFlexibleTypesFile()) - if (analyzeExhaust.isError()) { - throw EvaluateExceptionUtil.createEvaluateException(analyzeExhaust.error) + val analysisResult = this.getAnalysisResults(createFlexibleTypesFile()) + if (analysisResult.isError()) { + throw EvaluateExceptionUtil.createEvaluateException(analysisResult.error) } - val bindingContext = analyzeExhaust.bindingContext + val bindingContext = analysisResult.bindingContext bindingContext.getDiagnostics().firstOrNull { it.getSeverity() == Severity.ERROR }?.let { throw EvaluateExceptionUtil.createEvaluateException(DefaultErrorMessages.RENDERER.render(it)) } - analyzeExhaust + analysisResult } } } diff --git a/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java b/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java index e9d534d9893..cffaba6b11e 100644 --- a/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java +++ b/idea/src/org/jetbrains/jet/plugin/internal/KotlinBytecodeToolWindow.java @@ -37,7 +37,7 @@ import com.intellij.util.Alarm; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.OutputFile; import org.jetbrains.jet.OutputFileCollection; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.codegen.ClassBuilderFactories; import org.jetbrains.jet.codegen.CompilationErrorHandler; import org.jetbrains.jet.codegen.KotlinCodegenFacade; @@ -107,12 +107,12 @@ public class KotlinBytecodeToolWindow extends JPanel implements Disposable { GenerationState state; try { - AnalyzeExhaust exhaust = ResolvePackage.getAnalysisResults(jetFile); - if (exhaust.isError()) { - return printStackTraceToString(exhaust.getError()); + AnalysisResult result = ResolvePackage.getAnalysisResults(jetFile); + if (result.isError()) { + return printStackTraceToString(result.getError()); } state = new GenerationState(jetFile.getProject(), ClassBuilderFactories.TEST, Progress.DEAF, - exhaust.getModuleDescriptor(), exhaust.getBindingContext(), + result.getModuleDescriptor(), result.getBindingContext(), Collections.singletonList(jetFile), !enableAssertions.isSelected(), !enableAssertions.isSelected(), GenerationState.GenerateClassFilter.GENERATE_ALL, !enableInline.isSelected(), !enableOptimization.isSelected(), null, null, diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt index 75c314be2b1..cec46fc7605 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt @@ -144,9 +144,9 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { private val typeCandidates = HashMap>(); { - val exhaust = config.currentFile.getAnalysisResults() - currentFileContext = exhaust.bindingContext - currentFileModule = exhaust.moduleDescriptor + val result = config.currentFile.getAnalysisResults() + currentFileContext = result.bindingContext + currentFileModule = result.moduleDescriptor } public var placement: CallablePlacement by Delegates.notNull() diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt index 86cd69dacc5..d5eed8fb417 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterActionFactory.kt @@ -66,15 +66,15 @@ object CreateParameterActionFactory: JetSingleIntentionActionFactory() { } override fun createAction(diagnostic: Diagnostic): IntentionAction? { - val exhaust = (diagnostic.getPsiFile() as? JetFile)?.getAnalysisResults() ?: return null - val context = exhaust.bindingContext + val result = (diagnostic.getPsiFile() as? JetFile)?.getAnalysisResults() ?: return null + val context = result.bindingContext val refExpr = QuickFixUtil.getParentElementOfType(diagnostic, javaClass()) ?: return null if (refExpr.getQualifiedElement() != refExpr) return null val varExpected = refExpr.getAssignmentByLHS() != null - val paramType = refExpr.getExpressionForTypeGuess().guessTypes(context, exhaust.moduleDescriptor).let { + val paramType = refExpr.getExpressionForTypeGuess().guessTypes(context, result.moduleDescriptor).let { when (it.size) { 0 -> KotlinBuiltIns.getInstance().getAnyType() 1 -> it.first() diff --git a/idea/tests/org/jetbrains/jet/plugin/highlighter/AbstractDiagnosticMessageTest.java b/idea/tests/org/jetbrains/jet/plugin/highlighter/AbstractDiagnosticMessageTest.java index b5fde8cc5f0..7bace05ce14 100644 --- a/idea/tests/org/jetbrains/jet/plugin/highlighter/AbstractDiagnosticMessageTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/highlighter/AbstractDiagnosticMessageTest.java @@ -25,7 +25,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -82,8 +82,8 @@ public abstract class AbstractDiagnosticMessageTest extends JetLiteFixture { MessageType messageType = getMessageTypeDirective(directives); JetFile psiFile = createPsiFile(null, fileName, loadFile(fileName)); - AnalyzeExhaust analyzeExhaust = JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile); - BindingContext bindingContext = analyzeExhaust.getBindingContext(); + AnalysisResult analysisResult = JvmResolveUtil.analyzeOneFileWithJavaIntegration(psiFile); + BindingContext bindingContext = analysisResult.getBindingContext(); List diagnostics = ContainerUtil.filter(bindingContext.getDiagnostics().all(), new Condition() { @Override diff --git a/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java index 71e5a16e468..f734f5bfb3e 100644 --- a/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java +++ b/js/js.frontend/src/org/jetbrains/k2js/analyze/TopDownAnalyzerFacadeForJS.java @@ -23,7 +23,7 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.context.ContextPackage; import org.jetbrains.jet.context.GlobalContextImpl; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs; @@ -58,7 +58,7 @@ public final class TopDownAnalyzerFacadeForJS { //TODO: refactor @NotNull - public static AnalyzeExhaust analyzeFiles( + public static AnalysisResult analyzeFiles( @NotNull Collection files, @NotNull Predicate filesToAnalyzeCompletely, @NotNull Config config @@ -91,7 +91,7 @@ public final class TopDownAnalyzerFacadeForJS { files : Config.withJsLibAdded(files, config); injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, allFiles); - return AnalyzeExhaust.success(trace.getBindingContext(), owner); + return AnalysisResult.success(trace.getBindingContext(), owner); } finally { injector.destroy(); diff --git a/js/js.tests/test/org/jetbrains/k2js/test/config/LibrarySourcesConfigWithCaching.java b/js/js.tests/test/org/jetbrains/k2js/test/config/LibrarySourcesConfigWithCaching.java index a991227f643..c9dff47b4af 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/config/LibrarySourcesConfigWithCaching.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/config/LibrarySourcesConfigWithCaching.java @@ -23,7 +23,7 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.PsiManager; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiFactory; @@ -44,7 +44,7 @@ public class LibrarySourcesConfigWithCaching extends LibrarySourcesConfig { Arrays.asList("@" + STDLIB_JS_MODULE_NAME, PathUtil.getKotlinPathsForDistDirectory().getJsLibJarPath().getAbsolutePath()); private static List jsLibFiles; - private static AnalyzeExhaust exhaust; + private static AnalysisResult result; private BindingContext libraryContext; private ModuleDescriptor libraryModule; @@ -79,7 +79,7 @@ public class LibrarySourcesConfigWithCaching extends LibrarySourcesConfig { @Override public ModuleDescriptor getLibraryModule() { if (libraryModule == null) { - libraryModule = getExhaust().getModuleDescriptor(); + libraryModule = getResult().getModuleDescriptor(); } return libraryModule; @@ -90,8 +90,8 @@ public class LibrarySourcesConfigWithCaching extends LibrarySourcesConfig { public BindingContext getLibraryContext() { if (libraryContext == null) { //TODO check errors? - // TopDownAnalyzerFacadeForJS.checkForErrors(allLibFiles, exhaust.getBindingContext()); - libraryContext = getExhaust().getBindingContext(); + // TopDownAnalyzerFacadeForJS.checkForErrors(allLibFiles, result.getBindingContext()); + libraryContext = getResult().getBindingContext(); } return libraryContext; @@ -118,17 +118,17 @@ public class LibrarySourcesConfigWithCaching extends LibrarySourcesConfig { return jetFile; } - private AnalyzeExhaust getExhaust() { - if (exhaust == null) { + private AnalysisResult getResult() { + if (result == null) { //noinspection AssignmentToStaticFieldFromInstanceMethod - exhaust = TopDownAnalyzerFacadeForJS.analyzeFiles( + result = TopDownAnalyzerFacadeForJS.analyzeFiles( generateLibFiles(), Predicates.alwaysFalse(), createConfigWithoutLibFiles(getProject(), getModuleId(), getTarget()) ); } - return exhaust; + return result; } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java b/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java index e58362d18c1..d53c8ddce7b 100644 --- a/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/facade/K2JSTranslator.java @@ -34,7 +34,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.OutputFileCollection; import org.jetbrains.jet.SimpleOutputFile; import org.jetbrains.jet.SimpleOutputFileCollection; -import org.jetbrains.jet.analyzer.AnalyzeExhaust; +import org.jetbrains.jet.analyzer.AnalysisResult; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -154,10 +154,10 @@ public final class K2JSTranslator { public JsProgram generateProgram(@NotNull List filesToTranslate, @NotNull MainCallParameters mainCallParameters) throws TranslationException { - AnalyzeExhaust analyzeExhaust = TopDownAnalyzerFacadeForJS.analyzeFiles(filesToTranslate, Predicates.alwaysTrue(), config); - BindingContext bindingContext = analyzeExhaust.getBindingContext(); + AnalysisResult analysisResult = TopDownAnalyzerFacadeForJS.analyzeFiles(filesToTranslate, Predicates.alwaysTrue(), config); + BindingContext bindingContext = analysisResult.getBindingContext(); TopDownAnalyzerFacadeForJS.checkForErrors(Config.withJsLibAdded(filesToTranslate, config), bindingContext); - ModuleDescriptor moduleDescriptor = analyzeExhaust.getModuleDescriptor(); + ModuleDescriptor moduleDescriptor = analysisResult.getModuleDescriptor(); return Translation.generateAst(bindingContext, filesToTranslate, mainCallParameters, moduleDescriptor, config); }