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

Rename: Renderer -> DiagnosticParameterRenderer and move it out of descriptors module

Browse Source 
DescriptorRenderer is no longer a renderer
DescriptorRenderers should not be used to render diagnostic parameters explicitly
This commit is contained in:
Pavel V. Talanov
2016-02-16 18:40:59 +03:00
parent 41f5b5e8b1
commit 4f18b3da53
20 changed files with 197 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java
+2 -2
View File
@@ -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) {
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/AbstractDiagnosticWithParametersRenderer.java
-39
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+8 -24
View File
@@ -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);
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticFactoryToRendererMap.java
+7 -8
View File
@@ -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));
}
core/descriptors/src/org/jetbrains/kotlin/renderer/Renderer.kt → compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticParameterRenderer.kt
+5 -5
View File
@@ -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)
}
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRenderer.java
+1 -3
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticRendererUtil.kt
+1 -2
View File
@@ -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 + "'"
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithMultiParametersRenderer.java
-35
View File
@@ -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());
}
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters1Renderer.java
-37
View File
@@ -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)};
}
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters2Renderer.java
-41
View File
@@ -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)};
}
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DiagnosticWithParameters3Renderer.java
-47
View File
@@ -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)};
}
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/MultiRenderer.java
-24
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
+41 -28
View File
@@ -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)
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/TabledDescriptorRenderer.java
+1 -2
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/diagnosticsWithParameterRenderers.kt
+93
View File
@@ -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>
}
core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt
+2 -2
View File
@@ -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
idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/HtmlTabledDescriptorRenderer.java
+6 -2
View File
@@ -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;
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeErrorMessages.java
+11 -12
View File
@@ -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);
idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
+16 -13
View File
@@ -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()
}
js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/jsRenderers.kt
+3 -3
View File
@@ -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 =