Types renderer improvements.

2012-03-05 17:07:21 +04:00
parent 77f9d27b2c
commit 1e3734a2d3
2 changed files with 73 additions and 3 deletions
@@ -392,7 +392,11 @@ public class JetStandardClasses {
    }

    public static boolean isFunctionType(@NotNull JetType type) {
-        return FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) || RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor());
+        return FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) || isReceiverFunctionType(type);
+    }
+
+    public static boolean isReceiverFunctionType(@NotNull JetType type) {
+        return RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor());
    }

    @Nullable
@@ -23,6 +23,7 @@ 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;
@@ -73,7 +74,8 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
        }
    };

-    private DescriptorRenderer() {}
+    private DescriptorRenderer() {
+    }

    protected String renderKeyword(String keyword) {
        return keyword;
@@ -82,11 +84,75 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
    public String renderType(JetType type) {
        if (type == null) {
            return escape("[NULL]");
-        } else {
+        }
+        else if (JetStandardClasses.isUnit(type)) {
+            return escape("Unit" + (type.isNullable() ? "?" : ""));
+        }
+        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));
+        }
+        else {
            return escape(type.toString());
        }
    }

+    protected String renderTupleType(JetType type) {
+        StringBuilder sb = new StringBuilder("#(");
+        for (Iterator<TypeProjection> iterator = type.getArguments().iterator(); iterator.hasNext(); ) {
+            TypeProjection argument = iterator.next();
+            sb.append(renderType(argument.getType()));
+            if (iterator.hasNext()) {
+                sb.append(", ");
+            }
+        }
+        sb.append(")");
+
+        if (type.isNullable()) {
+            sb.append("?");
+        }
+
+        return sb.toString();
+    }
+
+    protected String renderFunctionType(JetType type, boolean receiver) {
+        StringBuilder sb = new StringBuilder("(");
+        List<TypeProjection> 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) {
+        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 + ")?";
+        }
+        return rendered;
+    }
+
    protected String escape(String s) {
        return s;
    }