diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
index 76642a3e194..8b059e3b5a9 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
@@ -20,9 +20,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap;
+import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticParameterRenderer;
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.renderer.Renderer;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -30,7 +30,7 @@ import java.util.List;
 
 public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
 
-    private static final Renderer<ConflictingJvmDeclarationsData> CONFLICTING_JVM_DECLARATIONS_DATA = new Renderer<ConflictingJvmDeclarationsData>() {
+    private static final DiagnosticParameterRenderer<ConflictingJvmDeclarationsData> CONFLICTING_JVM_DECLARATIONS_DATA = new DiagnosticParameterRenderer<ConflictingJvmDeclarationsData>() {
         @NotNull
         @Override
         public String render(@NotNull ConflictingJvmDeclarationsData data) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/AbstractDiagnosticWithParametersRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/AbstractDiagnosticWithParametersRenderer.java
deleted file mode 100644
index dda0858a925..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/AbstractDiagnosticWithParametersRenderer.java
+++ /dev/null
@@ -1,39 +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.diagnostics.rendering;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.diagnostics.Diagnostic;
-
-import java.text.MessageFormat;
-
-public abstract class AbstractDiagnosticWithParametersRenderer<D extends Diagnostic> implements DiagnosticRenderer<D> {
-    @NotNull private final MessageFormat messageFormat;
-
-    protected AbstractDiagnosticWithParametersRenderer(@NotNull String message) {
-        messageFormat = new MessageFormat(message);
-    }
-
-    @NotNull
-    @Override
-    public String render(@NotNull D diagnostic) {
-        return messageFormat.format(renderParameters(diagnostic));
-    }
-
-    @NotNull
-    public abstract Object[] renderParameters(@NotNull D diagnostic);
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
index b939e22e73a..32f27ead4af 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.diagnostics.rendering;
 
 import com.intellij.openapi.extensions.ExtensionPointName;
-import kotlin.Unit;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -30,8 +29,6 @@ import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression;
 import org.jetbrains.kotlin.psi.KtTypeConstraint;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
-import org.jetbrains.kotlin.renderer.Renderer;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker.VarianceConflictDiagnosticData;
 import org.jetbrains.kotlin.types.KotlinType;
 import org.jetbrains.kotlin.util.MappedExtensionProvider;
@@ -44,7 +41,6 @@ import java.util.List;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 import static org.jetbrains.kotlin.diagnostics.rendering.Renderers.*;
-import static org.jetbrains.kotlin.renderer.DescriptorRenderer.*;
 
 public class DefaultErrorMessages {
 
@@ -95,18 +91,6 @@ public class DefaultErrorMessages {
         return null;
     }
 
-    public static final DescriptorRenderer DEPRECATION_RENDERER = DescriptorRenderer.ONLY_NAMES_WITH_SHORT_TYPES.withOptions(
-            new Function1<DescriptorRendererOptions, Unit>() {
-                @Override
-                public Unit invoke(DescriptorRendererOptions options) {
-                    options.setWithoutTypeParameters(false);
-                    options.setReceiverAfterName(false);
-                    options.setRenderAccessors(true);
-                    return Unit.INSTANCE;
-                }
-            }
-    );
-
     static {
         MAP.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", ELEMENT_TEXT);
 
@@ -143,7 +127,7 @@ public class DefaultErrorMessages {
                     }
                 });
 
-        MAP.put(MEMBER_PROJECTED_OUT, "Out-projected type ''{1}'' prohibits the use of ''{0}''", DescriptorRenderer.FQ_NAMES_IN_TYPES, RENDER_TYPE);
+        MAP.put(MEMBER_PROJECTED_OUT, "Out-projected type ''{1}'' prohibits the use of ''{0}''", FQ_NAMES_IN_TYPES, RENDER_TYPE);
         MAP.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", TO_STRING, TO_STRING);
         MAP.put(DEPRECATED_MODIFIER_PAIR, "Modifier ''{0}'' is deprecated in presence of ''{1}''", TO_STRING, TO_STRING);
         MAP.put(REPEATED_MODIFIER, "Repeated ''{0}''", TO_STRING);
@@ -188,7 +172,7 @@ public class DefaultErrorMessages {
         MAP.put(MIXING_NAMED_AND_POSITIONED_ARGUMENTS, "Mixing named and positioned arguments is not allowed");
         MAP.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter");
         MAP.put(NAMED_PARAMETER_NOT_FOUND, "Cannot find a parameter with this name: {0}", ELEMENT_TEXT);
-        MAP.put(NAMED_ARGUMENTS_NOT_ALLOWED, "Named arguments are not allowed for {0}", new Renderer<BadNamedArgumentsTarget>() {
+        MAP.put(NAMED_ARGUMENTS_NOT_ALLOWED, "Named arguments are not allowed for {0}", new DiagnosticParameterRenderer<BadNamedArgumentsTarget>() {
             @NotNull
             @Override
             public String render(@NotNull BadNamedArgumentsTarget target) {
@@ -404,7 +388,7 @@ public class DefaultErrorMessages {
 
         MAP.put(IMPLICIT_CAST_TO_ANY, "Conditional branch result of type {0} is implicitly cast to {1}",
                 RENDER_TYPE, RENDER_TYPE);
-        MAP.put(EXPRESSION_EXPECTED, "{0} is not an expression, and only expressions are allowed here", new Renderer<KtExpression>() {
+        MAP.put(EXPRESSION_EXPECTED, "{0} is not an expression, and only expressions are allowed here", new DiagnosticParameterRenderer<KtExpression>() {
             @NotNull
             @Override
             public String render(@NotNull KtExpression expression) {
@@ -500,7 +484,7 @@ public class DefaultErrorMessages {
         MAP.put(UNEXPECTED_SAFE_CALL, "Safe-call is not allowed here");
         MAP.put(UNNECESSARY_NOT_NULL_ASSERTION, "Unnecessary non-null assertion (!!) on a non-null receiver of type {0}", RENDER_TYPE);
         MAP.put(NOT_NULL_ASSERTION_ON_LAMBDA_EXPRESSION, "Non-null assertion (!!) is called on a lambda expression");
-        MAP.put(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", new Renderer<KtTypeConstraint>() {
+        MAP.put(NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER, "{0} does not refer to a type parameter of {1}", new DiagnosticParameterRenderer<KtTypeConstraint>() {
             @NotNull
             @Override
             public String render(@NotNull KtTypeConstraint typeConstraint) {
@@ -561,7 +545,7 @@ public class DefaultErrorMessages {
         MAP.put(INCONSISTENT_TYPE_PARAMETER_VALUES, "Type parameter {0} of ''{1}'' has inconsistent values: {2}", NAME, NAME, RENDER_COLLECTION_OF_TYPES);
         MAP.put(INCONSISTENT_TYPE_PARAMETER_BOUNDS, "Type parameter {0} of ''{1}'' has inconsistent bounds: {2}", NAME, NAME, RENDER_COLLECTION_OF_TYPES);
 
-        MAP.put(EQUALITY_NOT_APPLICABLE, "Operator ''{0}'' cannot be applied to ''{1}'' and ''{2}''", new Renderer<KtSimpleNameExpression>() {
+        MAP.put(EQUALITY_NOT_APPLICABLE, "Operator ''{0}'' cannot be applied to ''{1}'' and ''{2}''", new DiagnosticParameterRenderer<KtSimpleNameExpression>() {
             @NotNull
             @Override
             public String render(@NotNull KtSimpleNameExpression nameExpression) {
@@ -616,7 +600,7 @@ public class DefaultErrorMessages {
 
         MAP.put(FUNCTION_EXPECTED, "Expression ''{0}''{1} cannot be invoked as a function. " +
                                    "The function '" + OperatorNameConventions.INVOKE.asString() + "()' is not found",
-                ELEMENT_TEXT, new Renderer<KotlinType>() {
+                ELEMENT_TEXT, new DiagnosticParameterRenderer<KotlinType>() {
                     @NotNull
                     @Override
                     public String render(@NotNull KotlinType type) {
@@ -624,7 +608,7 @@ public class DefaultErrorMessages {
                         return " of type '" + RENDER_TYPE.render(type) + "'";
                     }
                 });
-        MAP.put(FUNCTION_CALL_EXPECTED, "Function invocation ''{0}({1})'' expected", ELEMENT_TEXT, new Renderer<Boolean>() {
+        MAP.put(FUNCTION_CALL_EXPECTED, "Function invocation ''{0}({1})'' expected", ELEMENT_TEXT, new DiagnosticParameterRenderer<Boolean>() {
             @NotNull
             @Override
             public String render(@NotNull Boolean hasValueParameters) {
@@ -665,7 +649,7 @@ public class DefaultErrorMessages {
 
         MAP.put(TYPE_INFERENCE_FAILED_ON_SPECIAL_CONSTRUCT, "Type inference for control flow expression failed. Please specify its type explicitly.");
 
-        MAP.put(WRONG_NUMBER_OF_TYPE_ARGUMENTS, "{0,choice,0#No type arguments|1#Type argument|1<{0,number,integer} type arguments} expected", (Renderer) null);
+        MAP.put(WRONG_NUMBER_OF_TYPE_ARGUMENTS, "{0,choice,0#No type arguments|1#Type argument|1<{0,number,integer} type arguments} expected", (DiagnosticParameterRenderer) null);
         MAP.put(NO_TYPE_ARGUMENTS_ON_RHS, "{0,choice,0#No type arguments|1#Type argument|1<{0,number,integer} type arguments} expected. " +
                                                            "Use ''{1}'' if you don''t want to pass type arguments", null, STRING);
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
index 2089c4c0e8d..86c55e78d23 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
@@ -20,7 +20,6 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.*;
-import org.jetbrains.kotlin.renderer.Renderer;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -54,29 +53,29 @@ public final class DiagnosticFactoryToRendererMap {
         map.put(factory, new SimpleDiagnosticRenderer(message));
     }
 
-    public <E extends PsiElement, A> void put(@NotNull DiagnosticFactory1<E, A> factory, @NotNull String message, @Nullable Renderer<? super A> rendererA) {
+    public <E extends PsiElement, A> void put(@NotNull DiagnosticFactory1<E, A> factory, @NotNull String message, @Nullable DiagnosticParameterRenderer<? super A> rendererA) {
         checkMutability();
         map.put(factory, new DiagnosticWithParameters1Renderer<A>(message, rendererA));
     }
 
     public <E extends PsiElement, A> void put(@NotNull DiagnosticFactory1<E, A> factory, @NotNull String message, @NotNull MultiRenderer<? super A> rendererA) {
         checkMutability();
-        map.put(factory, new DiagnosticWithMultiParametersRenderer<A>(message, rendererA));
+        map.put(factory, new DiagnosticWithParametersMultiRenderer<A>(message, rendererA));
     }
 
     public <E extends PsiElement, A, B> void put(@NotNull DiagnosticFactory2<E, A, B> factory,
             @NotNull String message,
-            @Nullable Renderer<? super A> rendererA,
-            @Nullable Renderer<? super B> rendererB) {
+            @Nullable DiagnosticParameterRenderer<? super A> rendererA,
+            @Nullable DiagnosticParameterRenderer<? super B> rendererB) {
         checkMutability();
         map.put(factory, new DiagnosticWithParameters2Renderer<A, B>(message, rendererA, rendererB));
     }
 
     public <E extends PsiElement, A, B, C> void put(@NotNull DiagnosticFactory3<E, A, B, C> factory,
             @NotNull String message,
-            @Nullable Renderer<? super A> rendererA,
-            @Nullable Renderer<? super B> rendererB,
-            @Nullable  Renderer<? super C> rendererC) {
+            @Nullable DiagnosticParameterRenderer<? super A> rendererA,
+            @Nullable DiagnosticParameterRenderer<? super B> rendererB,
+            @Nullable  DiagnosticParameterRenderer<? super C> rendererC) {
         checkMutability();
         map.put(factory, new DiagnosticWithParameters3Renderer<A, B, C>(message, rendererA, rendererB, rendererC));
     }
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/Renderer.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticParameterRenderer.kt
similarity index 74%
rename from core/descriptors/src/org/jetbrains/kotlin/renderer/Renderer.kt
rename to compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticParameterRenderer.kt
index 92f056bab3a..5efb23fcc28 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/Renderer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticParameterRenderer.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 JetBrains s.r.o.
+ * Copyright 2010-2016 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.
@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.renderer
+package org.jetbrains.kotlin.diagnostics.rendering
 
-interface Renderer<in O> {
+interface DiagnosticParameterRenderer<in O> {
     fun render(obj: O): String
 }
 
-fun <O> Renderer(block: (O) -> String) = object : Renderer<O> {
+fun <O> Renderer(block: (O) -> String) = object : DiagnosticParameterRenderer<O> {
     override fun render(obj: O) = block(obj)
-}
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRenderer.java
index ce38a60cb49..5471c87dae6 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRenderer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRenderer.java
@@ -18,10 +18,8 @@ package org.jetbrains.kotlin.diagnostics.rendering;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
-import org.jetbrains.kotlin.renderer.Renderer;
 
-public interface DiagnosticRenderer<D extends Diagnostic> extends Renderer<D> {
+public interface DiagnosticRenderer<D extends Diagnostic> {
     @NotNull
-    @Override
     String render(@NotNull D diagnostic);
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererUtil.kt
index 43301f77f2b..644df659948 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererUtil.kt
@@ -18,9 +18,8 @@ package org.jetbrains.kotlin.diagnostics.rendering
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.renderer.Renderer
 
-fun <P : Any> renderParameter(parameter: P, renderer: Renderer<P>?): Any = renderer?.render(parameter) ?: parameter
+fun <P : Any> renderParameter(parameter: P, renderer: DiagnosticParameterRenderer<P>?): Any = renderer?.render(parameter) ?: parameter
 
 fun ClassDescriptor.renderKindWithName(): String = DescriptorRenderer.getClassKindPrefix(this) + " '" + name + "'"
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithMultiParametersRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithMultiParametersRenderer.java
deleted file mode 100644
index b0f0f7820e0..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithMultiParametersRenderer.java
+++ /dev/null
@@ -1,35 +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.diagnostics.rendering;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters1;
-
-public class DiagnosticWithMultiParametersRenderer<A> extends AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters1<?,A>> {
-    @NotNull private final MultiRenderer<? super A> renderersForA;
-
-    public DiagnosticWithMultiParametersRenderer(@NotNull String message, @NotNull MultiRenderer<? super A> renderersForA) {
-        super(message);
-        this.renderersForA = renderersForA;
-    }
-
-    @NotNull
-    @Override
-    public Object[] renderParameters(@NotNull DiagnosticWithParameters1<?, A> diagnostic) {
-        return renderersForA.render(diagnostic.getA());
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters1Renderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters1Renderer.java
deleted file mode 100644
index de90a13a4db..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters1Renderer.java
+++ /dev/null
@@ -1,37 +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.diagnostics.rendering;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters1;
-import org.jetbrains.kotlin.renderer.Renderer;
-
-public class DiagnosticWithParameters1Renderer<A> extends AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters1<?, A>> {
-    private final Renderer<? super A> rendererForA;
-
-    public DiagnosticWithParameters1Renderer(@NotNull String message, @Nullable Renderer<? super A> rendererForA) {
-        super(message);
-        this.rendererForA = rendererForA;
-    }
-
-    @NotNull
-    @Override
-    public Object[] renderParameters(@NotNull DiagnosticWithParameters1<?, A> diagnostic) {
-        return new Object[]{DiagnosticRendererUtilKt.renderParameter(diagnostic.getA(), rendererForA)};
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters2Renderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters2Renderer.java
deleted file mode 100644
index 6dbfdb20d52..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters2Renderer.java
+++ /dev/null
@@ -1,41 +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.diagnostics.rendering;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters2;
-import org.jetbrains.kotlin.renderer.Renderer;
-
-public class DiagnosticWithParameters2Renderer<A, B> extends AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters2<?, A, B>> {
-    private final Renderer<? super A> rendererForA;
-    private final Renderer<? super B> rendererForB;
-
-    public DiagnosticWithParameters2Renderer(@NotNull String message, @Nullable Renderer<? super A> rendererForA, @Nullable Renderer<? super B> rendererForB) {
-        super(message);
-        this.rendererForA = rendererForA;
-        this.rendererForB = rendererForB;
-    }
-
-    @NotNull
-    @Override
-    public Object[] renderParameters(@NotNull DiagnosticWithParameters2<?, A, B> diagnostic) {
-        return new Object[]{
-                DiagnosticRendererUtilKt.renderParameter(diagnostic.getA(), rendererForA),
-                DiagnosticRendererUtilKt.renderParameter(diagnostic.getB(), rendererForB)};
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters3Renderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters3Renderer.java
deleted file mode 100644
index 2e2f547d1e7..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters3Renderer.java
+++ /dev/null
@@ -1,47 +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.diagnostics.rendering;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters3;
-import org.jetbrains.kotlin.renderer.Renderer;
-
-public class DiagnosticWithParameters3Renderer<A, B, C> extends AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters3<?, A, B, C>> {
-    private final Renderer<? super A> rendererForA;
-    private final Renderer<? super B> rendererForB;
-    private final Renderer<? super C> rendererForC;
-
-    public DiagnosticWithParameters3Renderer(@NotNull String message,
-            @Nullable Renderer<? super A> rendererForA,
-            @Nullable Renderer<? super B> rendererForB,
-            @Nullable Renderer<? super C> rendererForC) {
-        super(message);
-        this.rendererForA = rendererForA;
-        this.rendererForB = rendererForB;
-        this.rendererForC = rendererForC;
-    }
-
-    @NotNull
-    @Override
-    public Object[] renderParameters(@NotNull DiagnosticWithParameters3<?, A, B, C> diagnostic) {
-        return new Object[]{
-                DiagnosticRendererUtilKt.renderParameter(diagnostic.getA(), rendererForA),
-                DiagnosticRendererUtilKt.renderParameter(diagnostic.getB(), rendererForB),
-                DiagnosticRendererUtilKt.renderParameter(diagnostic.getC(), rendererForC)};
-    }
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/MultiRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/MultiRenderer.java
deleted file mode 100644
index 162ae4c59d9..00000000000
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/MultiRenderer.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright 2010-2016 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.diagnostics.rendering;
-
-import org.jetbrains.annotations.NotNull;
-
-public interface MultiRenderer<O> {
-    @NotNull
-    String[] render(@NotNull O object);
-}
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
index 88a73f25d79..1703a62e537 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.renderer.Renderer
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.MemberComparator
 import org.jetbrains.kotlin.resolve.calls.inference.*
@@ -56,7 +55,7 @@ object Renderers {
 
     private val LOG = Logger.getInstance(Renderers::class.java)
 
-    @JvmField val TO_STRING: Renderer<Any> = Renderer {
+    @JvmField val TO_STRING = Renderer<Any> {
         element ->
         if (element is DeclarationDescriptor) {
             LOG.warn("Diagnostic renderer TO_STRING was used to render an instance of DeclarationDescriptor.\n"
@@ -66,17 +65,17 @@ object Renderers {
         element.toString()
     }
 
-    @JvmField val STRING: Renderer<String> = Renderer { it }
+    @JvmField val STRING = Renderer<String> { it }
 
-    @JvmField val THROWABLE: Renderer<Throwable> = Renderer {
+    @JvmField val THROWABLE = Renderer<Throwable> {
         val writer = StringWriter()
         it.printStackTrace(PrintWriter(writer))
         StringUtil.first(writer.toString(), 2048, true)
     }
 
-    @JvmField val NAME: Renderer<Named> = Renderer { it.name.asString() }
+    @JvmField val NAME = Renderer<Named> { it.name.asString() }
 
-    @JvmField val DECLARATION_NAME_WITH_KIND: Renderer<DeclarationDescriptor> = Renderer {
+    @JvmField val DECLARATION_NAME_WITH_KIND = Renderer<DeclarationDescriptor> {
         val declarationKindWithSpace = when (it) {
             is PackageFragmentDescriptor -> "package "
             is ClassDescriptor -> "${it.renderKind()} "
@@ -89,7 +88,7 @@ object Renderers {
         "$declarationKindWithSpace'${it.name.asString()}'"
     }
 
-    @JvmField val NAME_OF_PARENT_OR_FILE: Renderer<DeclarationDescriptor> = Renderer {
+    @JvmField val NAME_OF_PARENT_OR_FILE = Renderer<DeclarationDescriptor> {
         if (DescriptorUtils.isTopLevelDeclaration(it) && it is DeclarationDescriptorWithVisibility && it.visibility == Visibilities.PRIVATE) {
             "file"
         }
@@ -98,21 +97,21 @@ object Renderers {
         }
     }
 
-    @JvmField val ELEMENT_TEXT: Renderer<PsiElement> = Renderer { it.text }
+    @JvmField val ELEMENT_TEXT = Renderer<PsiElement> { it.text }
 
-    @JvmField val DECLARATION_NAME: Renderer<KtNamedDeclaration> = Renderer { it.nameAsSafeName.asString() }
+    @JvmField val DECLARATION_NAME = Renderer<KtNamedDeclaration> { it.nameAsSafeName.asString() }
 
-    @JvmField val RENDER_CLASS_OR_OBJECT: Renderer<KtClassOrObject> = Renderer {
+    @JvmField val RENDER_CLASS_OR_OBJECT = Renderer {
         classOrObject: KtClassOrObject ->
         val name = if (classOrObject.getName() != null) " '" + classOrObject.getName() + "'" else ""
         if (classOrObject is KtClass) "Class" + name else "Object" + name
     }
 
-    @JvmField val RENDER_CLASS_OR_OBJECT_NAME: Renderer<ClassDescriptor> = Renderer { it.renderKindWithName() }
+    @JvmField val RENDER_CLASS_OR_OBJECT_NAME = Renderer<ClassDescriptor> { it.renderKindWithName() }
 
-    @JvmField val RENDER_TYPE: Renderer<KotlinType> = Renderer { DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(it) }
+    @JvmField val RENDER_TYPE = Renderer<KotlinType> { DescriptorRenderer.FQ_NAMES_IN_TYPES.renderType(it) }
 
-    @JvmField val RENDER_POSITION_VARIANCE: Renderer<Variance> = Renderer {
+    @JvmField val RENDER_POSITION_VARIANCE = Renderer {
         variance: Variance ->
         when (variance) {
             Variance.INVARIANT -> "invariant"
@@ -121,7 +120,7 @@ object Renderers {
         }
     }
 
-    @JvmField val AMBIGUOUS_CALLS: Renderer<Collection<ResolvedCall<*>>> = Renderer {
+    @JvmField val AMBIGUOUS_CALLS = Renderer {
         calls: Collection<ResolvedCall<*>> ->
         calls
                 .map { it.resultingDescriptor }
@@ -129,7 +128,7 @@ object Renderers {
                 .joinToString(separator = "\n", prefix = "\n") { DescriptorRenderer.FQ_NAMES_IN_TYPES.render(it) }
     }
 
-    @JvmStatic fun <T> commaSeparated(itemRenderer: Renderer<T>): Renderer<Collection<T>> = Renderer {
+    @JvmStatic fun <T> commaSeparated(itemRenderer: DiagnosticParameterRenderer<T>) = Renderer<Collection<T>> {
         collection ->
         buildString {
             val iterator = collection.iterator()
@@ -143,23 +142,23 @@ object Renderers {
         }
     }
 
-    @JvmField val TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER = Renderer<InferenceErrorData> {
         renderConflictingSubstitutionsInferenceError(it, TabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER = Renderer<InferenceErrorData> {
         renderParameterConstraintError(it, TabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER = Renderer<InferenceErrorData> {
         renderNoInformationForParameterError(it, TabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER = Renderer<InferenceErrorData> {
         renderUpperBoundViolatedInferenceError(it, TabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val TYPE_INFERENCE_CANNOT_CAPTURE_TYPES_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val TYPE_INFERENCE_CANNOT_CAPTURE_TYPES_RENDERER = Renderer<InferenceErrorData> {
         renderCannotCaptureTypeParameterError(it, TabledDescriptorRenderer.create()).toString()
     }
 
@@ -349,7 +348,7 @@ object Renderers {
         return result
     }
 
-    @JvmField val CLASSES_OR_SEPARATED: Renderer<Collection<ClassDescriptor>> = Renderer {
+    @JvmField val CLASSES_OR_SEPARATED = Renderer<Collection<ClassDescriptor>> {
         descriptors ->
         buildString {
             var index = 0
@@ -368,9 +367,9 @@ object Renderers {
 
     private fun renderTypes(types: Collection<KotlinType>) = StringUtil.join(types, { RENDER_TYPE.render(it) }, ", ")
 
-    @JvmField val RENDER_COLLECTION_OF_TYPES: Renderer<Collection<KotlinType>> = Renderer { renderTypes(it) }
+    @JvmField val RENDER_COLLECTION_OF_TYPES = Renderer<Collection<KotlinType>> { renderTypes(it) }
 
-    private fun renderConstraintSystem(constraintSystem: ConstraintSystem, renderTypeBounds: Renderer<TypeBounds>): String {
+    private fun renderConstraintSystem(constraintSystem: ConstraintSystem, renderTypeBounds: DiagnosticParameterRenderer<TypeBounds>): String {
         val typeBounds = linkedSetOf<TypeBounds>()
         for (variable in constraintSystem.typeVariables) {
             typeBounds.add(constraintSystem.getTypeBounds(variable))
@@ -380,9 +379,9 @@ object Renderers {
                ConstraintsUtil.getDebugMessageForStatus(constraintSystem.status)
     }
 
-    @JvmField val RENDER_CONSTRAINT_SYSTEM: Renderer<ConstraintSystem> = Renderer { renderConstraintSystem(it, RENDER_TYPE_BOUNDS) }
+    @JvmField val RENDER_CONSTRAINT_SYSTEM = Renderer<ConstraintSystem> { renderConstraintSystem(it, RENDER_TYPE_BOUNDS) }
 
-    @JvmField val RENDER_CONSTRAINT_SYSTEM_SHORT: Renderer<ConstraintSystem> = Renderer { renderConstraintSystem(it, RENDER_TYPE_BOUNDS_SHORT) }
+    @JvmField val RENDER_CONSTRAINT_SYSTEM_SHORT = Renderer<ConstraintSystem> { renderConstraintSystem(it, RENDER_TYPE_BOUNDS_SHORT) }
 
     private fun renderTypeBounds(typeBounds: TypeBounds, short: Boolean): String {
         val renderBound = { bound: Bound ->
@@ -399,9 +398,9 @@ object Renderers {
             "$typeVariableName ${StringUtil.join(typeBounds.bounds, renderBound, ", ")}"
     }
 
-    @JvmField val RENDER_TYPE_BOUNDS: Renderer<TypeBounds> = Renderer { renderTypeBounds(it, short = false) }
+    @JvmField val RENDER_TYPE_BOUNDS = Renderer<TypeBounds> { renderTypeBounds(it, short = false) }
 
-    @JvmField val RENDER_TYPE_BOUNDS_SHORT: Renderer<TypeBounds> = Renderer { renderTypeBounds(it, short = true) }
+    @JvmField val RENDER_TYPE_BOUNDS_SHORT = Renderer<TypeBounds> { renderTypeBounds(it, short = true) }
 
     private fun renderDebugMessage(message: String, inferenceErrorData: InferenceErrorData) = buildString {
         append(message)
@@ -425,7 +424,7 @@ object Renderers {
 
     private val WHEN_MISSING_LIMIT = 7
 
-    @JvmField val RENDER_WHEN_MISSING_CASES: Renderer<List<WhenMissingCase>> = Renderer {
+    @JvmField val RENDER_WHEN_MISSING_CASES = Renderer<List<WhenMissingCase>> {
         if (!it.hasUnknown) {
             val list = it.joinToString(", ", limit = WHEN_MISSING_LIMIT) { "'$it'" }
             val branches = if (it.size > 1) "branches" else "branch"
@@ -435,4 +434,18 @@ object Renderers {
             "'else' branch"
         }
     }
+
+    @JvmField val FQ_NAMES_IN_TYPES = DescriptorRenderer.FQ_NAMES_IN_TYPES.asRenderer()
+    @JvmField val COMPACT = DescriptorRenderer.COMPACT.asRenderer()
+    @JvmField val SHORT_NAMES_IN_TYPES = DescriptorRenderer.SHORT_NAMES_IN_TYPES.asRenderer()
+    @JvmField val COMPACT_WITH_MODIFIERS = DescriptorRenderer.COMPACT_WITH_MODIFIERS.asRenderer()
+    @JvmField val DEPRECATION_RENDERER = DescriptorRenderer.ONLY_NAMES_WITH_SHORT_TYPES.withOptions {
+        withoutTypeParameters = false
+        receiverAfterName = false
+        renderAccessors = true
+    }.asRenderer()
 }
+
+fun DescriptorRenderer.asRenderer() = Renderer<DeclarationDescriptor> {
+    render(it)
+}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
index 431dee923fa..f9677583991 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.Table
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.TableRenderer.TableRow;
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.TextRenderer.TextElement;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.renderer.Renderer;
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition;
 import org.jetbrains.kotlin.types.KotlinType;
 
@@ -156,7 +155,7 @@ public class TabledDescriptorRenderer {
     }
 
     @NotNull
-    public Renderer<KotlinType> getTypeRenderer() {
+    public DiagnosticParameterRenderer<KotlinType> getTypeRenderer() {
         return Renderers.RENDER_TYPE;
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/diagnosticsWithParameterRenderers.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/diagnosticsWithParameterRenderers.kt
new file mode 100644
index 00000000000..42b567ed62c
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/diagnosticsWithParameterRenderers.kt
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2010-2016 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.diagnostics.rendering
+
+import org.jetbrains.kotlin.diagnostics.*
+import java.text.MessageFormat
+
+
+abstract class AbstractDiagnosticWithParametersRenderer<D : Diagnostic> protected constructor(message: String) : DiagnosticRenderer<D> {
+    private val messageFormat: MessageFormat
+
+    init {
+        messageFormat = MessageFormat(message)
+    }
+
+    override fun render(obj: D): String {
+        return messageFormat.format(renderParameters(obj))
+    }
+
+    abstract fun renderParameters(diagnostic: D): Array<out Any>
+
+}
+
+
+class DiagnosticWithParameters1Renderer<A : Any>(
+        message: String,
+        private val rendererForA: DiagnosticParameterRenderer<A>?
+) : AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters1<*, A>>(message) {
+
+    override fun renderParameters(diagnostic: DiagnosticWithParameters1<*, A>): Array<out Any> {
+        return arrayOf(renderParameter(diagnostic.a, rendererForA))
+    }
+
+
+}
+
+class DiagnosticWithParameters2Renderer<A : Any, B : Any>(
+        message: String,
+        private val rendererForA: DiagnosticParameterRenderer<A>?,
+        private val rendererForB: DiagnosticParameterRenderer<B>?
+) : AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters2<*, A, B>>(message) {
+
+    override fun renderParameters(diagnostic: DiagnosticWithParameters2<*, A, B>): Array<out Any> {
+        return arrayOf(
+                renderParameter(diagnostic.a, rendererForA),
+                renderParameter(diagnostic.b, rendererForB)
+        )
+    }
+}
+
+class DiagnosticWithParameters3Renderer<A : Any, B : Any, C : Any>(
+        message: String,
+        private val rendererForA: DiagnosticParameterRenderer<A>?,
+        private val rendererForB: DiagnosticParameterRenderer<B>?,
+        private val rendererForC: DiagnosticParameterRenderer<C>?
+) : AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters3<*, A, B, C>>(message) {
+
+    override fun renderParameters(diagnostic: DiagnosticWithParameters3<*, A, B, C>): Array<out Any> {
+        return arrayOf(
+                renderParameter(diagnostic.a, rendererForA),
+                renderParameter(diagnostic.b, rendererForB),
+                renderParameter(diagnostic.c, rendererForC)
+        )
+    }
+}
+
+class DiagnosticWithParametersMultiRenderer<A>(
+        message: String,
+        private val renderer: MultiRenderer<A>
+) : AbstractDiagnosticWithParametersRenderer<DiagnosticWithParameters1<*, A>>(message) {
+
+    override fun renderParameters(diagnostic: DiagnosticWithParameters1<*, A>): Array<out Any> {
+        return renderer.render(diagnostic.a)
+    }
+}
+
+interface MultiRenderer<in A> {
+    fun render(a: A): Array<String>
+}
diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
index c3b56b33ccc..a9c9c9c380c 100644
--- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
+++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.TypeProjection
 
-abstract class DescriptorRenderer : Renderer<DeclarationDescriptor> {
+abstract class DescriptorRenderer {
     fun withOptions(changeOptions: DescriptorRendererOptions.() -> Unit): DescriptorRenderer {
         val options = (this as DescriptorRendererImpl).options.copy()
         options.changeOptions()
@@ -48,7 +48,7 @@ abstract class DescriptorRenderer : Renderer<DeclarationDescriptor> {
 
     abstract fun renderAnnotation(annotation: AnnotationDescriptor, target: AnnotationUseSiteTarget? = null): String
 
-    override abstract fun render(declarationDescriptor: DeclarationDescriptor): String
+    abstract fun render(declarationDescriptor: DeclarationDescriptor): String
 
     abstract fun renderValueParameters(parameters: Collection<ValueParameterDescriptor>, synthesizedParameterNames: Boolean): String
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
index 8b90e923ec5..1681670d7e1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
@@ -22,12 +22,16 @@ import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
+import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticParameterRenderer;
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer;
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.TableRenderer.DescriptorRow;
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.TableRenderer.FunctionArgumentsRow;
 import org.jetbrains.kotlin.diagnostics.rendering.TabledDescriptorRenderer.TableRenderer.TableRow;
 import org.jetbrains.kotlin.idea.highlighter.renderersUtil.RenderersUtilKt;
-import org.jetbrains.kotlin.renderer.*;
+import org.jetbrains.kotlin.renderer.DescriptorRenderer;
+import org.jetbrains.kotlin.renderer.DescriptorRendererModifier;
+import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
+import org.jetbrains.kotlin.renderer.RenderingFormat;
 import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPosition;
 import org.jetbrains.kotlin.types.KotlinType;
 
@@ -43,7 +47,7 @@ public class HtmlTabledDescriptorRenderer extends TabledDescriptorRenderer {
 
     @NotNull
     @Override
-    public Renderer<KotlinType> getTypeRenderer() {
+    public DiagnosticParameterRenderer<KotlinType> getTypeRenderer() {
         return IdeRenderers.HTML_RENDER_TYPE;
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
index 03fe6560531..941e062eba6 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.diagnostics.TypeMismatchDueToTypeProjectionsData;
 import org.jetbrains.kotlin.diagnostics.rendering.*;
 import org.jetbrains.kotlin.js.resolve.diagnostics.ErrorsJs;
 import org.jetbrains.kotlin.js.resolve.diagnostics.JsCallDataHtmlRenderer;
-import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 
 import java.net.URL;
 
@@ -76,7 +75,7 @@ public class IdeErrorMessages {
                                 HTML_RENDER_TYPE.render(object.getExpectedType()),
                                 HTML_RENDER_TYPE.render(object.getExpressionType()),
                                 HTML_RENDER_TYPE.render(object.getReceiverType()),
-                                DescriptorRenderer.HTML.render(object.getCallableDescriptor())
+                                HTML.render(object.getCallableDescriptor())
                         };
                     }
                 });
@@ -110,30 +109,30 @@ public class IdeErrorMessages {
                                            "<tr><td>Parameter:</td><td>{1}</td></tr></table></html>", HTML_RENDER_TYPE, HTML_RENDER_TYPE);
 
         MAP.put(RETURN_TYPE_MISMATCH_ON_OVERRIDE, "<html>Return type is ''{0}'', which is not a subtype of overridden<br/>" +
-                                                  "{1}</html>", HTML_RENDER_RETURN_TYPE, DescriptorRenderer.HTML);
+                                                  "{1}</html>", HTML_RENDER_RETURN_TYPE, HTML);
         MAP.put(RETURN_TYPE_MISMATCH_ON_INHERITANCE, "<html>Return types of inherited members are incompatible:<br/>{0},<br/>{1}</html>",
-                DescriptorRenderer.HTML, DescriptorRenderer.HTML);
+                HTML, HTML);
 
         MAP.put(PROPERTY_TYPE_MISMATCH_ON_OVERRIDE, "<html>Property type is ''{0}'', which is not a subtype type of overridden<br/>" +
-                                                  "{1}</html>", HTML_RENDER_RETURN_TYPE, DescriptorRenderer.HTML);
+                                                  "{1}</html>", HTML_RENDER_RETURN_TYPE, HTML);
         MAP.put(VAR_TYPE_MISMATCH_ON_OVERRIDE, "<html>Var-property type is ''{0}'', which is not a type of overridden<br/>" +
-                                                    "{1}</html>", HTML_RENDER_RETURN_TYPE, DescriptorRenderer.HTML);
+                                                    "{1}</html>", HTML_RENDER_RETURN_TYPE, HTML);
         MAP.put(PROPERTY_TYPE_MISMATCH_ON_INHERITANCE, "<html>Types of inherited properties are incompatible:<br/>{0},<br/>{1}</html>",
-                DescriptorRenderer.HTML, DescriptorRenderer.HTML);
+                HTML, HTML);
         MAP.put(VAR_TYPE_MISMATCH_ON_INHERITANCE, "<html>Types of inherited var-properties do not match:<br/>{0},<br/>{1}</html>",
-                DescriptorRenderer.HTML, DescriptorRenderer.HTML);
+                HTML, HTML);
 
         MAP.put(VAR_OVERRIDDEN_BY_VAL, "<html>Val-property cannot override var-property<br />" +
-                                       "{1}</html>", DescriptorRenderer.HTML, DescriptorRenderer.HTML);
+                                       "{1}</html>", HTML, HTML);
         MAP.put(VAR_OVERRIDDEN_BY_VAL_BY_DELEGATION, "<html>Val-property cannot override var-property<br />" +
-                                       "{1}</html>", DescriptorRenderer.HTML, DescriptorRenderer.HTML);
+                                       "{1}</html>", HTML, HTML);
 
         MAP.put(ABSTRACT_MEMBER_NOT_IMPLEMENTED, "<html>{0} must be declared abstract or implement abstract member<br/>" +
                                                  "{1}</html>", RENDER_CLASS_OR_OBJECT,
-                DescriptorRenderer.HTML);
+                HTML);
 
         MAP.put(MANY_IMPL_MEMBER_NOT_IMPLEMENTED, "<html>{0} must override {1}<br />because it inherits many implementations of it</html>",
-                RENDER_CLASS_OR_OBJECT, DescriptorRenderer.HTML);
+                RENDER_CLASS_OR_OBJECT, HTML);
         MAP.put(CONFLICTING_OVERLOADS, "<html>''{0}''<br />conflicts with another declaration in {1}</html>",
                 IdeRenderers.HTML_COMPACT_WITH_MODIFIERS, Renderers.DECLARATION_NAME_WITH_KIND);
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
index 6ecd5dde134..b21f0747335 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
@@ -17,10 +17,11 @@
 package org.jetbrains.kotlin.idea.highlighter
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.diagnostics.rendering.Renderer
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers
+import org.jetbrains.kotlin.diagnostics.rendering.asRenderer
 import org.jetbrains.kotlin.idea.highlighter.renderersUtil.renderResolvedCall
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.renderer.Renderer
 import org.jetbrains.kotlin.resolve.MemberComparator
 import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
@@ -30,7 +31,7 @@ import kotlin.comparisons.compareBy
 
 object IdeRenderers {
 
-    @JvmField val HTML_AMBIGUOUS_CALLS: Renderer<Collection<ResolvedCall<*>>> = Renderer {
+    @JvmField val HTML_AMBIGUOUS_CALLS = Renderer {
         calls: Collection<ResolvedCall<*>> ->
             calls
                 .map { it.resultingDescriptor }
@@ -38,11 +39,11 @@ object IdeRenderers {
                 .joinToString("") { "<li>${DescriptorRenderer.HTML.render(it)}</li>" }
     }
 
-    @JvmField val HTML_RENDER_TYPE: Renderer<KotlinType> = Renderer {
+    @JvmField val HTML_RENDER_TYPE = Renderer<KotlinType> {
         DescriptorRenderer.HTML.renderType(it)
     }
 
-    @JvmField val HTML_NONE_APPLICABLE_CALLS: Renderer<Collection<ResolvedCall<*>>> = Renderer {
+    @JvmField val HTML_NONE_APPLICABLE_CALLS= Renderer {
         calls: Collection<ResolvedCall<*>> ->
             val comparator = compareBy(MemberComparator.INSTANCE) { c: ResolvedCall<*> -> c.resultingDescriptor }
             calls
@@ -50,32 +51,32 @@ object IdeRenderers {
                 .joinToString("") { "<li>${renderResolvedCall(it)}</li>" }
     }
 
-    @JvmField val HTML_TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val HTML_TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS_RENDERER = Renderer<InferenceErrorData> {
         Renderers.renderConflictingSubstitutionsInferenceError(it, HtmlTabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val HTML_TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val HTML_TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR_RENDERER = Renderer<InferenceErrorData> {
         Renderers.renderParameterConstraintError(it, HtmlTabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val HTML_TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val HTML_TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER_RENDERER = Renderer<InferenceErrorData> {
         Renderers.renderNoInformationForParameterError(it, HtmlTabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val HTML_TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER: Renderer<InferenceErrorData> = Renderer {
+    @JvmField val HTML_TYPE_INFERENCE_UPPER_BOUND_VIOLATED_RENDERER = Renderer<InferenceErrorData> {
         Renderers.renderUpperBoundViolatedInferenceError(it, HtmlTabledDescriptorRenderer.create()).toString()
     }
 
-    @JvmField val HTML_RENDER_RETURN_TYPE: Renderer<CallableMemberDescriptor> = Renderer {
+    @JvmField val HTML_RENDER_RETURN_TYPE = Renderer<CallableMemberDescriptor> {
         val returnType = it.returnType!!
         DescriptorRenderer.HTML.renderType(returnType)
     }
 
-    @JvmField val HTML_COMPACT_WITH_MODIFIERS: DescriptorRenderer = DescriptorRenderer.HTML.withOptions {
+    @JvmField val HTML_COMPACT_WITH_MODIFIERS = DescriptorRenderer.HTML.withOptions {
         withDefinedIn = false
-    }
+    }.asRenderer()
 
-    @JvmField val HTML_CONFLICTING_JVM_DECLARATIONS_DATA: Renderer<ConflictingJvmDeclarationsData> = Renderer {
+    @JvmField val HTML_CONFLICTING_JVM_DECLARATIONS_DATA = Renderer {
         data: ConflictingJvmDeclarationsData ->
 
         val conflicts = data.signatureOrigins
@@ -86,7 +87,9 @@ object IdeRenderers {
         "The following declarations have the same JVM signature (<code>${data.signature.name}${data.signature.desc}</code>):<br/>\n<ul>\n$conflicts</ul>"
     }
 
-    @JvmField val HTML_THROWABLE: Renderer<Throwable> = Renderer {
+    @JvmField val HTML_THROWABLE = Renderer<Throwable> {
         Renderers.THROWABLE.render(it).replace("\n", "<br/>")
     }
+
+    @JvmField val HTML = DescriptorRenderer.HTML.asRenderer()
 }
diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
index e9fc615aa59..66a5984a21b 100644
--- a/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
+++ b/js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.js.resolve.diagnostics
 
 import com.google.gwt.dev.js.rhino.Utils.isEndOfLine
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.renderer.Renderer
+import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticParameterRenderer
 
-object RenderFirstLineOfElementText : Renderer<PsiElement> {
+object RenderFirstLineOfElementText : DiagnosticParameterRenderer<PsiElement> {
     override fun render(element: PsiElement): String {
         val text = element.text
         val index = text.indexOf('\n')
@@ -28,7 +28,7 @@ object RenderFirstLineOfElementText : Renderer<PsiElement> {
     }
 }
 
-abstract class JsCallDataRenderer : Renderer<JsCallData> {
+abstract class JsCallDataRenderer : DiagnosticParameterRenderer<JsCallData> {
     protected abstract fun format(data: JsCallDataWithCode): String
 
     override fun render(data: JsCallData): String =