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

Rename: AnalyzeExhaust -> AnalysisResult

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