Types renderer improvements.

compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java

@@ -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

compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java

@@ -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;
     }