Get rid of unneeded MessageCollector implementations

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/MessageCollectorPlainTextToStream.java

@@ -1,44 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.cli.common.messages;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.io.PrintStream;
-import java.util.EnumSet;
-import java.util.Set;
-
-public class MessageCollectorPlainTextToStream implements MessageCollector {
-    public static final EnumSet<CompilerMessageSeverity> NON_VERBOSE = EnumSet.complementOf(CompilerMessageSeverity.VERBOSE);
-
-    public static final MessageCollector PLAIN_TEXT_TO_SYSTEM_ERR = new MessageCollectorPlainTextToStream(System.err, NON_VERBOSE);
-
-    private final PrintStream stream;
-    private final Set<CompilerMessageSeverity> severitiesToPrint;
-
-    public MessageCollectorPlainTextToStream(@NotNull PrintStream stream, @NotNull Set<CompilerMessageSeverity> severities) {
-        this.stream = stream;
-        this.severitiesToPrint = severities;
-    }
-
-    @Override
-    public void report(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) {
-        if (severitiesToPrint.contains(severity)) {
-            stream.println(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location));
-        }
-    }
-}

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/messages/PrintingMessageCollector.java

@@ -21,6 +21,9 @@ import org.jetbrains.annotations.NotNull;
 import java.io.PrintStream;
 
 public class PrintingMessageCollector implements MessageCollector {
+    public static final MessageCollector PLAIN_TEXT_TO_SYSTEM_ERR =
+            new PrintingMessageCollector(System.err, MessageRenderer.PLAIN_FULL_PATHS, false);
+
     private final boolean verbose;
     private final PrintStream errStream;
     private final MessageRenderer messageRenderer;

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.java

@@ -62,27 +62,13 @@ public final class AnalyzerWithCompilerReport {
         throw new IllegalStateException("Unknown severity: " + severity);
     }
 
-    @NotNull
     private static final DiagnosticFactory0<PsiErrorElement> SYNTAX_ERROR_FACTORY = DiagnosticFactory0.create(Severity.ERROR);
 
-    private boolean hasErrors = false;
+    private final MessageSeverityCollector messageCollector;
-    @NotNull
-    private final MessageCollector messageCollectorWrapper;
-    @Nullable
     private AnalysisResult analysisResult = null;
 
-    public AnalyzerWithCompilerReport(@NotNull final MessageCollector collector) {
+    public AnalyzerWithCompilerReport(@NotNull MessageCollector collector) {
-        messageCollectorWrapper = new MessageCollector() {
+        messageCollector = new MessageSeverityCollector(collector);
-            @Override
-            public void report(@NotNull CompilerMessageSeverity severity,
-                    @NotNull String message,
-                    @NotNull CompilerMessageLocation location) {
-                if (CompilerMessageSeverity.ERRORS.contains(severity)) {
-                    hasErrors = true;
-                }
-                collector.report(severity, message, location);
-            }
-        };
     }
 
     private static boolean reportDiagnostic(@NotNull Diagnostic diagnostic, @NotNull MessageCollector messageCollector) {
@@ -114,7 +100,7 @@ public final class AnalyzerWithCompilerReport {
                         "Incomplete hierarchy should be reported with names of unresolved superclasses: " + fqName;
                 message.append("    ").append(fqName).append(", unresolved: ").append(unresolved).append("\n");
             }
-            messageCollectorWrapper.report(CompilerMessageSeverity.ERROR, message.toString(), CompilerMessageLocation.NO_LOCATION);
+            messageCollector.report(CompilerMessageSeverity.ERROR, message.toString(), CompilerMessageLocation.NO_LOCATION);
         }
     }
 
@@ -138,8 +124,7 @@ public final class AnalyzerWithCompilerReport {
                     message.append("    ").append(error).append("\n");
                 }
             }
-            messageCollectorWrapper.report(CompilerMessageSeverity.ERROR,
+            messageCollector.report(CompilerMessageSeverity.ERROR, message.toString(), CompilerMessageLocation.NO_LOCATION);
-                                           message.toString(), CompilerMessageLocation.NO_LOCATION);
         }
     }
 
@@ -152,11 +137,12 @@ public final class AnalyzerWithCompilerReport {
             TraceBasedErrorReporter.AbiVersionErrorData data = bindingContext.get(TraceBasedErrorReporter.ABI_VERSION_ERRORS, kotlinClass);
             assert data != null;
             String path = toSystemDependentName(kotlinClass);
-            messageCollectorWrapper.report(CompilerMessageSeverity.ERROR,
+            messageCollector.report(
-                                           "Class '" + JvmClassName.byClassId(data.getClassId()) +
+                    CompilerMessageSeverity.ERROR,
-                                           "' was compiled with an incompatible version of Kotlin. " +
+                    "Class '" + JvmClassName.byClassId(data.getClassId()) + "' was compiled with an incompatible version of Kotlin. " +
-                                           "Its ABI version is " + data.getActualVersion() + ", expected ABI version is " + JvmAbi.VERSION,
+                    "Its ABI version is " + data.getActualVersion() + ", expected ABI version is " + JvmAbi.VERSION,
-                                           CompilerMessageLocation.create(path, 0, 0));
+                    CompilerMessageLocation.create(path, 0, 0)
+            );
         }
     }
 
@@ -170,7 +156,7 @@ public final class AnalyzerWithCompilerReport {
 
     private void reportSyntaxErrors(@NotNull Collection<JetFile> files) {
         for (JetFile file : files) {
-            reportSyntaxErrors(file, messageCollectorWrapper);
+            reportSyntaxErrors(file, messageCollector);
         }
     }
 
@@ -225,7 +211,7 @@ public final class AnalyzerWithCompilerReport {
     }
 
     public boolean hasErrors() {
-        return hasErrors;
+        return messageCollector.anyReported(CompilerMessageSeverity.ERROR);
     }
 
     public void analyzeAndReport(@NotNull Collection<JetFile> files, @NotNull Function0<AnalysisResult> analyzer) {
@@ -233,12 +219,11 @@ public final class AnalyzerWithCompilerReport {
         reportAbiVersionErrors();
         reportSyntaxErrors(files);
         //noinspection ConstantConditions
-        reportDiagnostics(analysisResult.getBindingContext().getDiagnostics(), messageCollectorWrapper);
+        reportDiagnostics(analysisResult.getBindingContext().getDiagnostics(), messageCollector);
         reportIncompleteHierarchies();
         reportAlternativeSignatureErrors();
     }
 
-
     private static class MyDiagnostic<E extends PsiElement> extends SimpleDiagnostic<E> {
         private final String message;
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -33,8 +33,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
-import org.jetbrains.kotlin.cli.common.messages.MessageCollectorToString;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -238,10 +236,10 @@ public class ReplInterpreter {
         JetFile psiFile = (JetFile) psiFileFactory.trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
         assert psiFile != null : "Script file not analyzed at line " + lineNumber + ": " + fullText;
 
-        MessageCollectorToString errorCollector = new MessageCollectorToString();
+        ReplMessageCollectorWrapper errorCollector = new ReplMessageCollectorWrapper();
 
         AnalyzerWithCompilerReport.SyntaxErrorReport syntaxErrorReport =
-                AnalyzerWithCompilerReport.reportSyntaxErrors(psiFile, errorCollector);
+                AnalyzerWithCompilerReport.reportSyntaxErrors(psiFile, errorCollector.getMessageCollector());
 
         if (syntaxErrorReport.isHasErrors() && syntaxErrorReport.isAllErrorsAtEof()) {
             previousIncompleteLines.add(line);
@@ -339,7 +337,7 @@ public class ReplInterpreter {
     }
 
     @Nullable
-    private ScriptDescriptor doAnalyze(@NotNull JetFile psiFile, @NotNull MessageCollector messageCollector) {
+    private ScriptDescriptor doAnalyze(@NotNull JetFile psiFile, @NotNull ReplMessageCollectorWrapper messageCollector) {
         scriptDeclarationFactory.setDelegateFactory(
                 new FileBasedDeclarationProviderFactory(resolveSession.getStorageManager(), Collections.singletonList(psiFile)));
 
@@ -352,7 +350,9 @@ public class ReplInterpreter {
             trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, resolveSession.getPackageFragment(FqName.ROOT));
         }
 
-        boolean hasErrors = AnalyzerWithCompilerReport.reportDiagnostics(trace.getBindingContext().getDiagnostics(), messageCollector);
+        boolean hasErrors = AnalyzerWithCompilerReport.reportDiagnostics(
+                trace.getBindingContext().getDiagnostics(), messageCollector.getMessageCollector()
+        );
         if (hasErrors) {
             return null;
         }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplMessageCollectorWrapper.java

@@ -14,27 +14,30 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.common.messages;
+package org.jetbrains.kotlin.cli.jvm.repl;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
+import org.jetbrains.kotlin.cli.common.messages.MessageRenderer;
+import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 
-public class MessageCollectorToString implements MessageCollector {
+public class ReplMessageCollectorWrapper {
-    private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-    private final MessageCollector actualCollector = new MessageCollectorPlainTextToStream(new PrintStream(outputStream),
-                                                                                           MessageCollectorPlainTextToStream.NON_VERBOSE);
-
-    @Override
-    public void report(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) {
-        actualCollector.report(severity, message, location);
-    }
-
     private static final Charset UTF8 = Charset.forName("utf-8");
 
+    private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+    private final MessageCollector actualCollector =
+            new PrintingMessageCollector(new PrintStream(outputStream), MessageRenderer.PLAIN_FULL_PATHS, false);
+
+    @NotNull
+    public MessageCollector getMessageCollector() {
+        return actualCollector;
+    }
+
     @NotNull
     public String getString() {
         return UTF8.decode(ByteBuffer.wrap(outputStream.toByteArray())).toString();

compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java

@@ -23,7 +23,7 @@ import junit.framework.TestCase;
 import junit.framework.TestSuite;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
-import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream;
+import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
@@ -91,8 +91,7 @@ public class TestlibTest extends UsefulTestCase {
 
         addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test");
         addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src");
-        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY,
+        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, PrintingMessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
-                          new MessageCollectorPlainTextToStream(System.out, MessageCollectorPlainTextToStream.NON_VERBOSE));
 
         myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.CliBaseTest;
 import org.jetbrains.kotlin.cli.common.ExitCode;
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
-import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream;
+import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector;
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -182,7 +182,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
         result.throwIfError();
 
         BindingContext bindingContext = result.getBindingContext();
-        AnalyzerWithCompilerReport.reportDiagnostics(bindingContext.getDiagnostics(), MessageCollectorPlainTextToStream.PLAIN_TEXT_TO_SYSTEM_ERR);
+        AnalyzerWithCompilerReport.reportDiagnostics(bindingContext.getDiagnostics(), PrintingMessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR);
 
         assertEquals("There should be no diagnostics", 0, Iterables.size(bindingContext.getDiagnostics()));
     }

compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java

@@ -77,7 +77,7 @@ public class ScriptTest {
             @NotNull List<JetScriptDefinition> scriptDefinitions
     ) {
         KotlinPaths paths = PathUtil.getKotlinPathsForDistDirectory();
-        MessageCollector messageCollector = MessageCollectorPlainTextToStream.PLAIN_TEXT_TO_SYSTEM_ERR;
+        MessageCollector messageCollector = PrintingMessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR;
 
         Disposable rootDisposable = Disposer.newDisposable();
         try {

idea/tests/org/jetbrains/kotlin/idea/highlighter/NoErrorsInStdlibTest.kt

@@ -16,20 +16,20 @@
 
 package org.jetbrains.kotlin.idea.highlighter
 
-import com.intellij.testFramework.LightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.JetJdkAndLibraryProjectDescriptor
-import com.intellij.openapi.vfs.VfsUtil
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
-import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream
 import com.intellij.openapi.projectRoots.Sdk
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import com.intellij.openapi.vfs.VfsUtil
-import kotlin.test.assertEquals
+import com.intellij.testFramework.LightProjectDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
+import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
+import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.diagnostics.Severity
-import kotlin.test.assertTrue
+import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
+import org.jetbrains.kotlin.idea.test.JetJdkAndLibraryProjectDescriptor
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.psi.JetFile
 import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 public class NoErrorsInStdlibTest : JetLightCodeInsightFixtureTestCase() {
     public fun testNoErrors() {
@@ -49,12 +49,12 @@ public class NoErrorsInStdlibTest : JetLightCodeInsightFixtureTestCase() {
                     val errors = bindingContext.getDiagnostics().all().filter { it.getSeverity() == Severity.ERROR }
 
                     if (errors.isNotEmpty()) {
-                        System.err.println("${psiFile.getName()}: ${errors.size} errors")
+                        System.err.println("${psiFile.getName()}: ${errors.size()} errors")
                         AnalyzerWithCompilerReport.reportDiagnostics(
-                                bindingContext.getDiagnostics(), MessageCollectorPlainTextToStream.PLAIN_TEXT_TO_SYSTEM_ERR
+                                bindingContext.getDiagnostics(), PrintingMessageCollector.PLAIN_TEXT_TO_SYSTEM_ERR
                         )
 
-                        totalErrors += errors.size
+                        totalErrors += errors.size()
                     }
                 }
             }