001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.cli.common.messages;
018
019 import com.google.common.collect.LinkedHashMultimap;
020 import com.google.common.collect.Multimap;
021 import org.jetbrains.annotations.NotNull;
022
023 import java.util.*;
024
025 public class GroupingMessageCollector implements MessageCollector {
026
027 private final MessageCollector delegate;
028
029 // File path (nullable) -> message
030 private final Multimap<String, Message> groupedMessages = LinkedHashMultimap.create();
031
032 public GroupingMessageCollector(@NotNull MessageCollector delegate) {
033 this.delegate = delegate;
034 }
035
036 @Override
037 public void clear() {
038 groupedMessages.clear();
039 }
040
041 @Override
042 public void report(
043 @NotNull CompilerMessageSeverity severity,
044 @NotNull String message,
045 @NotNull CompilerMessageLocation location
046 ) {
047 if (CompilerMessageSeverity.VERBOSE.contains(severity)) {
048 delegate.report(severity, message, location);
049 }
050 else {
051 groupedMessages.put(location.getPath(), new Message(severity, message, location));
052 }
053 }
054
055 @Override
056 public boolean hasErrors() {
057 for (Map.Entry<String, Message> entry : groupedMessages.entries()) {
058 if (entry.getValue().severity.isError()) {
059 return true;
060 }
061 }
062
063 return false;
064 }
065
066 public void flush() {
067 boolean hasErrors = hasErrors();
068
069 for (String path : sortedKeys()) {
070 for (Message message : groupedMessages.get(path)) {
071 if (!hasErrors || message.severity.isError() || message.severity == CompilerMessageSeverity.STRONG_WARNING) {
072 delegate.report(message.severity, message.message, message.location);
073 }
074 }
075 }
076
077 groupedMessages.clear();
078 }
079
080 @NotNull
081 private Collection<String> sortedKeys() {
082 List<String> sortedKeys = new ArrayList<String>(groupedMessages.keySet());
083 // ensure that messages with no location i.e. perf, incomplete hierarchy are always reported first
084 Collections.sort(sortedKeys, new Comparator<String>() {
085 @Override
086 public int compare(String o1, String o2) {
087 if (o1 == o2) return 0;
088 if (o1 == null) return -1;
089 if (o2 == null) return 1;
090 return o1.compareTo(o2);
091 }
092 });
093 return sortedKeys;
094 }
095
096 private static class Message {
097 private final CompilerMessageSeverity severity;
098 private final String message;
099 private final CompilerMessageLocation location;
100
101 private Message(@NotNull CompilerMessageSeverity severity, @NotNull String message, @NotNull CompilerMessageLocation location) {
102 this.severity = severity;
103 this.message = message;
104 this.location = location;
105 }
106
107 @Override
108 public boolean equals(Object o) {
109 if (this == o) return true;
110 if (o == null || getClass() != o.getClass()) return false;
111
112 Message message1 = (Message) o;
113
114 if (!location.equals(message1.location)) return false;
115 if (!message.equals(message1.message)) return false;
116 if (severity != message1.severity) return false;
117
118 return true;
119 }
120
121 @Override
122 public int hashCode() {
123 int result = severity.hashCode();
124 result = 31 * result + message.hashCode();
125 result = 31 * result + location.hashCode();
126 return result;
127 }
128 }
129 }