CONFLICTING_PLATFORM_DECLARATIONS moved to a JVM-specific class

compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java

@@ -27,13 +27,13 @@ import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
-import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.reflect.ReflectionTypes;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
+import org.jetbrains.jet.lang.resolve.java.diagnostics.ErrorsJvm;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.Collection;
@@ -306,7 +306,7 @@ public class GenerationState {
             }
 
             for (PsiElement element : elements) {
-                diagnostics.report(Errors.CONFLICTING_PLATFORM_DECLARATIONS.on(element, signature.getName() + signature.getDesc()));
+                diagnostics.report(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS.on(element, signature.getName() + signature.getDesc()));
             }
         }
     }

compiler/frontend.java/src/META-INF/services/org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages$Extension

@@ -0,0 +1 @@
+org.jetbrains.jet.lang.resolve.java.diagnostics.DefaultErrorMessagesJvm

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2014 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.jet.lang.resolve.java.diagnostics;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages;
+import org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticFactoryToRendererMap;
+
+import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.STRING;
+
+public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
+
+    public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap();
+
+    static {
+        MAP.put(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: ''{0}''", STRING);
+    }
+
+    @NotNull
+    @Override
+    public DiagnosticFactoryToRendererMap getMap() {
+        return MAP;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2014 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.jet.lang.resolve.java.diagnostics;
+
+import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory1;
+import org.jetbrains.jet.lang.diagnostics.Errors;
+
+import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_OR_DEFAULT;
+import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
+
+public interface ErrorsJvm {
+    DiagnosticFactory1<PsiElement, String> CONFLICTING_JVM_DECLARATIONS = DiagnosticFactory1.create(ERROR, DECLARATION_OR_DEFAULT);
+
+    @SuppressWarnings("UnusedDeclaration")
+    Object _initializer = new Object() {
+        {
+            Errors.Initializer.initializeFactoryNames(ErrorsJvm.class);
+        }
+    };
+}

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -20,6 +20,7 @@ import com.google.common.collect.ImmutableSet;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiNameIdentifierOwner;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.inference.InferenceErrorData;
@@ -203,7 +204,6 @@ public interface Errors {
     DiagnosticFactory0<JetNamedDeclaration> PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE = DiagnosticFactory0.create(ERROR, NAMED_ELEMENT);
 
     DiagnosticFactory2<JetDeclaration, CallableMemberDescriptor, String> CONFLICTING_OVERLOADS = DiagnosticFactory2.create(ERROR, DECLARATION);
-    DiagnosticFactory1<PsiElement, String> CONFLICTING_PLATFORM_DECLARATIONS = DiagnosticFactory1.create(ERROR, DECLARATION_OR_DEFAULT);
 
     DiagnosticFactory0<JetNamedDeclaration> NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticFactory0.create(WARNING, modifierSetPosition(
             JetTokens.OPEN_KEYWORD));
@@ -610,7 +610,11 @@ public interface Errors {
 
     class Initializer {
         static {
-            for (Field field : Errors.class.getFields()) {
+            initializeFactoryNames(Errors.class);
+        }
+
+        public static void initializeFactoryNames(@NotNull Class<?> aClass) {
+            for (Field field : aClass.getFields()) {
                 if (Modifier.isStatic(field.getModifiers())) {
                     try {
                         Object value = field.get(null);

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java

@@ -16,6 +16,9 @@
 
 package org.jetbrains.jet.lang.diagnostics.rendering;
 
+import com.google.common.collect.ImmutableList;
+import kotlin.Function1;
+import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory;
@@ -31,16 +34,40 @@ import org.jetbrains.jet.renderer.Renderer;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.Collection;
+import java.util.List;
+import java.util.ServiceLoader;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.diagnostics.rendering.Renderers.*;
 import static org.jetbrains.jet.renderer.DescriptorRenderer.*;
 
 public class DefaultErrorMessages {
-    public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap();
+
-    public static final DiagnosticRenderer<Diagnostic> RENDERER = new DispatchingDiagnosticRenderer(MAP);
+    public interface Extension {
+        @NotNull
+        DiagnosticFactoryToRendererMap getMap();
+    }
+
+    private static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap();
+    public static final List<DiagnosticFactoryToRendererMap> MAPS = ImmutableList.<DiagnosticFactoryToRendererMap>builder()
+                    .addAll(
+                            KotlinPackage.map(
+                                ServiceLoader.load(Extension.class, DefaultErrorMessages.class.getClassLoader()),
+                                new Function1<Extension, DiagnosticFactoryToRendererMap>() {
+                                    @Override
+                                    public DiagnosticFactoryToRendererMap invoke(Extension extension) {
+                                        return extension.getMap();
+                                    }
+                                }
+                            )
+                    )
+                    .add(MAP)
+                    .build();
+
+    public static final DiagnosticRenderer<Diagnostic> RENDERER = new DispatchingDiagnosticRenderer(MAPS);
 
     static {
+
         MAP.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", ELEMENT_TEXT);
 
         MAP.put(INVISIBLE_REFERENCE, "Cannot access ''{0}'': it is ''{1}'' in ''{2}''", NAME, TO_STRING, NAME);
@@ -392,7 +419,6 @@ public class DefaultErrorMessages {
                 RENDER_CLASS_OR_OBJECT, FQ_NAMES_IN_TYPES);
 
         MAP.put(CONFLICTING_OVERLOADS, "''{0}'' is already defined in {1}", COMPACT_WITH_MODIFIERS, STRING);
-        MAP.put(CONFLICTING_PLATFORM_DECLARATIONS, "Platform declaration clash: ''{0}''", STRING);
 
         MAP.put(FUNCTION_EXPECTED, "Expression ''{0}''{1} cannot be invoked as a function. The function 'invoke()' is not found", ELEMENT_TEXT, new Renderer<JetType>() {
             @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DispatchingDiagnosticRenderer.java

@@ -19,10 +19,12 @@ package org.jetbrains.jet.lang.diagnostics.rendering;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 
-public class DispatchingDiagnosticRenderer implements DiagnosticRenderer<Diagnostic> {
+import java.util.List;
-    private final DiagnosticFactoryToRendererMap[] maps;
 
-    public DispatchingDiagnosticRenderer(DiagnosticFactoryToRendererMap... maps) {
+public class DispatchingDiagnosticRenderer implements DiagnosticRenderer<Diagnostic> {
+    private final List<DiagnosticFactoryToRendererMap> maps;
+
+    public DispatchingDiagnosticRenderer(List<DiagnosticFactoryToRendererMap> maps) {
         this.maps = maps;
     }
 

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt

@@ -4,5 +4,5 @@ open class B {
 
 class C : B() {
     val x: Int
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>get()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt

@@ -4,5 +4,5 @@ open class B {
 }
 
 class C : B() {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt

@@ -4,5 +4,5 @@ trait T {
 
 class C : T {
     val x: Int
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>get() = 1<!>
+        <!CONFLICTING_JVM_DECLARATIONS!>get() = 1<!>
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt

@@ -4,5 +4,5 @@ trait T {
 }
 
 class C : T {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt

@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: List<String>)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: List<String>)<!> {}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: MutableList<String>)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: MutableList<String>)<!> {}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt

@@ -8,5 +8,5 @@ trait Bar<T> {
     fun foo(l: List<T>)
 }
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>class Baz(f: Foo<String>, b: Bar<Int>)<!>: Foo<String> by f, Bar<Int> by b {
+<!CONFLICTING_JVM_DECLARATIONS!>class Baz(f: Foo<String>, b: Bar<Int>)<!>: Foo<String> by f, Bar<Int> by b {
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt

@@ -5,5 +5,5 @@ trait Foo<T> {
 }
 
 class Bar(f: Foo<String>): Foo<String> by f {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(l: List<Int>)<!> {}
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(l: List<Int>)<!> {}
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt

@@ -2,5 +2,5 @@
 
 class G<T>
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: G<String>): G<Int><!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: G<String>): G<Int><!> {null!!}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: G<Int>): G<String><!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: G<Int>): G<String><!> {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt

@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: List<String>)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: List<String>)<!> {}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: java.util.List<String>)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: java.util.List<String>)<!> {}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt

@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: String)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: String)<!> {}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: String?)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: String?)<!> {}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt

@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: java.lang.String)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: java.lang.String)<!> {}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(s: String)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: String)<!> {}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt

@@ -1,4 +1,4 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T> foo(x: T): T<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T> foo(x: T): T<!> {null!!}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Any): Any<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: Any): Any<!> {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt

@@ -2,5 +2,5 @@
 
 trait Foo
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T: Foo> foo(x: T): T<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T: Foo> foo(x: T): T<!> {null!!}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Foo): Foo<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: Foo): Foo<!> {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt

@@ -3,6 +3,6 @@
 trait Foo
 trait Bar
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T: Foo> foo(x: T): T where T: Bar<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T: Foo> foo(x: T): T where T: Bar<!> {null!!}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Foo): Foo<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: Foo): Foo<!> {null!!}
 fun foo(x: Bar): Bar {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt

@@ -3,6 +3,6 @@
 trait Foo
 trait Bar
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun <T> foo(x: T): T where T: Foo, T: Bar<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun <T> foo(x: T): T where T: Foo, T: Bar<!> {null!!}
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Foo): Foo<!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: Foo): Foo<!> {null!!}
 fun foo(x: Bar): Bar {null!!}

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt

@@ -1,4 +1,4 @@
 class C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt

@@ -1,6 +1,6 @@
 class C {
     class object {
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
     }
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt

@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun foo(x: Any)<!> {}
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: Any)<!> {}
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun Any.foo()<!> {}
+    <!CONFLICTING_JVM_DECLARATIONS!>fun Any.foo()<!> {}
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX(t: Any)<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun getX(t: Any)<!> = 1
     val Any.x: Int
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>get()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun setX(x: Int)<!> {}
+    <!CONFLICTING_JVM_DECLARATIONS!>fun setX(x: Int)<!> {}
 
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>var x: Int<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>var x: Int<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt

@@ -1,8 +1,8 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun setX(x: Int)<!> {}
+    <!CONFLICTING_JVM_DECLARATIONS!>fun setX(x: Int)<!> {}
 
     var x: Int = 1
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>set(v) {}<!>
+        <!CONFLICTING_JVM_DECLARATIONS!>set(v) {}<!>
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt

@@ -1,6 +1,6 @@
 fun foo() {
     class C {
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
     }
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt

@@ -1,6 +1,6 @@
 class B {
     class C {
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
     }
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt

@@ -1,4 +1,4 @@
 object C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt

@@ -1,5 +1,5 @@
 fun foo() =
     object {
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
     }

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt

@@ -1,2 +1,2 @@
-<!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+<!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+<!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt

@@ -1,5 +1,5 @@
 // FILE: a.kt
-<!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+<!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
 
 // FILE: b.kt
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+<!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt

@@ -1,3 +1,3 @@
 val x: Int
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>get()<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1
-<!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+<!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1

compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt

@@ -1,5 +1,5 @@
 trait T {
     val x: Int
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>get()<!> = 1
+        <!CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun getX()<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/componentInheritedFromTrait.kt

@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 data class C(val c: Int) {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun `copy$default`(c: C, x: Int, m: Int)<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>fun `copy$default`(c: C, x: Int, m: Int)<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/defaults.kt

@@ -1,6 +1,6 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>class C<!> {
+<!CONFLICTING_JVM_DECLARATIONS!>class C<!> {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>fun `a$default`(c: C, x: Int, m: Int)<!> {}
+    <!CONFLICTING_JVM_DECLARATIONS!>fun `a$default`(c: C, x: Int, m: Int)<!> {}
     fun a(x: Int = 1) {}
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt

@@ -1,5 +1,5 @@
 trait Foo
 
 class Bar(f: Foo) : Foo by f {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>val `$delegate_0`: Foo?<!> = null
+    <!CONFLICTING_JVM_DECLARATIONS!>val `$delegate_0`: Foo?<!> = null
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class C {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>inner class D<!> {
+    <!CONFLICTING_JVM_DECLARATIONS!>inner class D<!> {
-        <!CONFLICTING_PLATFORM_DECLARATIONS!>val `this$0`: C?<!> = null
+        <!CONFLICTING_JVM_DECLARATIONS!>val `this$0`: C?<!> = null
     }
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt

@@ -3,5 +3,5 @@ trait T {
 }
 
 class C : T {
-    <!CONFLICTING_PLATFORM_DECLARATIONS!>val x<!> = 1
+    <!CONFLICTING_JVM_DECLARATIONS!>val x<!> = 1
 }

compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt

@@ -7,5 +7,5 @@ trait T2 {
         get() = 1
 }
 
-<!CONFLICTING_PLATFORM_DECLARATIONS!>class C : T1, T2<!> {
+<!CONFLICTING_JVM_DECLARATIONS!>class C : T1, T2<!> {
 }

idea/src/org/jetbrains/jet/plugin/highlighter/IdeErrorMessages.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.plugin.highlighter;
 
+import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticFactoryToRendererMap;
@@ -36,7 +37,7 @@ import static org.jetbrains.jet.plugin.highlighter.IdeRenderers.*;
  */
 public class IdeErrorMessages {
     public static final DiagnosticFactoryToRendererMap MAP = new DiagnosticFactoryToRendererMap();
-    public static final DiagnosticRenderer<Diagnostic> RENDERER = new DispatchingDiagnosticRenderer(MAP, DefaultErrorMessages.MAP);
+    public static final DiagnosticRenderer<Diagnostic> RENDERER = new DispatchingDiagnosticRenderer(ContainerUtil.concat(true, DefaultErrorMessages.MAPS, MAP));
 
     static {
         MAP.put(TYPE_MISMATCH, "<html>Type mismatch.<table><tr><td>Required:</td><td>{0}</td></tr><tr><td>Found:</td><td>{1}</td></tr></table></html>",