From 78b7c32cd595a17a13932e4dde3345f3d8544931 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Tue, 6 Mar 2012 20:49:36 +0400 Subject: [PATCH] Refactored JetStandardClasses and DescriptorRenderer: renderer for tuple and function types share common code. --- .../jet/lang/types/JetStandardClasses.java | 35 +++++++-- .../jet/resolve/DescriptorRenderer.java | 72 ++++++++----------- 2 files changed, 60 insertions(+), 47 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java index cb8ded05218..d6fd63cd403 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java @@ -346,6 +346,15 @@ public class JetStandardClasses { return TUPLE_CONSTRUCTORS.contains(type.getConstructor()); } + public static List getTupleElementTypes(@NotNull JetType type) { + assert isTupleType(type); + List result = Lists.newArrayList(); + for (TypeProjection typeProjection : type.getArguments()) { + result.add(typeProjection.getType()); + } + return result; + } + public static JetType getLabeledTupleType(List annotations, List arguments) { // TODO return getTupleType(annotations, toTypes(arguments)); @@ -411,18 +420,32 @@ public class JetStandardClasses { @NotNull public static List getValueParameters(@NotNull FunctionDescriptor functionDescriptor, @NotNull JetType type) { assert isFunctionType(type); - List arguments = type.getArguments(); - int first = RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) ? 1 : 0; - int last = arguments.size() - 2; + int receiverOffset = getReceiverType(type) != null ? 1 : 0; List valueParameters = Lists.newArrayList(); - for (int i = first; i <= last; i++) { - JetType parameterType = arguments.get(i).getType(); - ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl(functionDescriptor, i - first, Collections.emptyList(), "p" + i, false, parameterType, false, null); + List parameterTypes = getParameterTypesFromFunctionType(type); + for (int i = 0; i < parameterTypes.size(); i++) { + JetType parameterType = parameterTypes.get(i); + ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl( + functionDescriptor, i, Collections.emptyList(), + "p" + (i + receiverOffset), false, parameterType, false, null); valueParameters.add(valueParameterDescriptor); } return valueParameters; } + @NotNull + public static List getParameterTypesFromFunctionType(@NotNull JetType type) { + assert isFunctionType(type); + List arguments = type.getArguments(); + int first = RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) ? 1 : 0; + int last = arguments.size() - 2; + List parameterTypes = Lists.newArrayList(); + for (int i = first; i <= last; i++) { + parameterTypes.add(arguments.get(i).getType()); + } + return parameterTypes; + } + @NotNull public static JetType getReturnTypeFromFunctionType(@NotNull JetType type) { assert isFunctionType(type); diff --git a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java index ec74bb7c476..6e4b2ee9467 100644 --- a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java +++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java @@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.diagnostics.Renderer; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetStandardClasses; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lexer.JetTokens; import java.util.Collection; @@ -91,26 +90,26 @@ public class DescriptorRenderer implements Renderer { else if (JetStandardClasses.isTupleType(type)) { return escape(renderTupleType(type)); } - else if (JetStandardClasses.isReceiverFunctionType(type)) { - return escape(renderReceiverFunctionType(type)); - } else if (JetStandardClasses.isFunctionType(type)) { - return escape(renderFunctionType(type, false)); + return escape(renderFunctionType(type)); } else { return escape(type.toString()); } } - protected String renderTupleType(JetType type) { - StringBuilder sb = new StringBuilder("#("); - for (Iterator iterator = type.getArguments().iterator(); iterator.hasNext(); ) { - TypeProjection argument = iterator.next(); - sb.append(renderType(argument.getType())); + private void appendTypes(StringBuilder result, List types) { + for (Iterator iterator = types.iterator(); iterator.hasNext(); ) { + result.append(renderType(iterator.next())); if (iterator.hasNext()) { - sb.append(", "); + result.append(", "); } } + } + + protected String renderTupleType(JetType type) { + StringBuilder sb = new StringBuilder("#("); + appendTypes(sb, JetStandardClasses.getTupleElementTypes(type)); sb.append(")"); if (type.isNullable()) { @@ -120,37 +119,24 @@ public class DescriptorRenderer implements Renderer { return sb.toString(); } - protected String renderFunctionType(JetType type, boolean receiver) { - StringBuilder sb = new StringBuilder("("); - List arguments = type.getArguments(); - for (int idx = receiver ? 1 : 0; idx < arguments.size(); idx++) { - if (idx + 1 == arguments.size()) { - sb.append(") -> "); - } - TypeProjection argument = arguments.get(idx); - sb.append(renderType(argument.getType())); - if (idx + 2 < arguments.size()) { - sb.append(", "); - } - } - - return receiver ? sb.toString() : appendNullability(type, sb); - } - - protected String renderReceiverFunctionType(JetType type) { + private String renderFunctionType(JetType type) { StringBuilder sb = new StringBuilder(); - sb.append(renderType(type.getArguments().get(0).getType())).append(".").append(renderFunctionType(type, true)); - - return appendNullability(type, sb); - } - - private String appendNullability(JetType type, StringBuilder sb) { - String rendered = sb.toString(); - if (type.isNullable()) { - rendered = "(" + rendered + ")?"; + JetType receiverType = JetStandardClasses.getReceiverType(type); + if (receiverType != null) { + sb.append(renderType(receiverType)); + sb.append("."); } - return rendered; + + sb.append("("); + appendTypes(sb, JetStandardClasses.getParameterTypesFromFunctionType(type)); + sb.append(") -> "); + sb.append(renderType(JetStandardClasses.getReturnTypeFromFunctionType(type))); + + if (type.isNullable()) { + return "(" + sb + ")?"; + } + return sb.toString(); } protected String escape(String s) { @@ -278,7 +264,9 @@ public class DescriptorRenderer implements Renderer { public Void visitFunctionDescriptor(FunctionDescriptor descriptor, StringBuilder builder) { renderModality(descriptor.getModality(), builder); builder.append(renderKeyword("fun")).append(" "); - renderTypeParameters(descriptor.getTypeParameters(), builder); + if (renderTypeParameters(descriptor.getTypeParameters(), builder)) { + builder.append(" "); + } ReceiverDescriptor receiver = descriptor.getReceiverParameter(); if (receiver.exists()) { @@ -315,7 +303,7 @@ public class DescriptorRenderer implements Renderer { return null; } - private void renderTypeParameters(List typeParameters, StringBuilder builder) { + private boolean renderTypeParameters(List typeParameters, StringBuilder builder) { if (!typeParameters.isEmpty()) { builder.append(lt()); for (Iterator iterator = typeParameters.iterator(); iterator.hasNext(); ) { @@ -326,7 +314,9 @@ public class DescriptorRenderer implements Renderer { } } builder.append("> "); + return true; } + return false; } @Override