Updated DescriptorRenderer to to be aware of types like Iterator<#(Int, Boolean)>

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

@@ -422,26 +422,26 @@ public class JetStandardClasses {
         assert isFunctionType(type);
         int receiverOffset = getReceiverType(type) != null ? 1 : 0;
         List<ValueParameterDescriptor> valueParameters = Lists.newArrayList();
-        List<JetType> parameterTypes = getParameterTypesFromFunctionType(type);
+        List<TypeProjection> parameterTypes = getParameterTypeProjectionsFromFunctionType(type);
         for (int i = 0; i < parameterTypes.size(); i++) {
-            JetType parameterType = parameterTypes.get(i);
+            TypeProjection parameterType = parameterTypes.get(i);
             ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl(
                     functionDescriptor, i, Collections.<AnnotationDescriptor>emptyList(),
-                    "p" + (i + receiverOffset), false, parameterType, false, null);
+                    "p" + (i + receiverOffset), false, parameterType.getType(), false, null);
             valueParameters.add(valueParameterDescriptor);
         }
         return valueParameters;
     }
 
     @NotNull
-    public static List<JetType> getParameterTypesFromFunctionType(@NotNull JetType type) {
+    public static List<TypeProjection> getParameterTypeProjectionsFromFunctionType(@NotNull JetType type) {
         assert isFunctionType(type);
         List<TypeProjection> arguments = type.getArguments();
         int first = RECEIVER_FUNCTION_TYPE_CONSTRUCTORS.contains(type.getConstructor()) ? 1 : 0;
         int last = arguments.size() - 2;
-        List<JetType> parameterTypes = Lists.newArrayList();
+        List<TypeProjection> parameterTypes = Lists.newArrayList();
         for (int i = first; i <= last; i++) {
-            parameterTypes.add(arguments.get(i).getType());
+            parameterTypes.add(arguments.get(i));
         }
         return parameterTypes;
     }

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

@@ -23,6 +23,8 @@ 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.lang.types.Variance;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collection;
@@ -94,10 +96,24 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
             return escape(renderFunctionType(type));
         }
         else {
-            return escape(type.toString());
+            return escape(renderDefaultType(type));
         }
     }
 
+    private String renderDefaultType(JetType type) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(type.getConstructor());
+        if (!type.getArguments().isEmpty()) {
+            sb.append("<");
+            appendTypeProjections(sb, type.getArguments());
+            sb.append(">");
+        }
+        if (type.isNullable()) {
+            sb.append("?");
+        }
+        return sb.toString();
+    }
+
     private void appendTypes(StringBuilder result, List<JetType> types) {
         for (Iterator<JetType> iterator = types.iterator(); iterator.hasNext(); ) {
             result.append(renderType(iterator.next()));
@@ -107,6 +123,19 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
         }
     }
 
+    private void appendTypeProjections(StringBuilder result, List<TypeProjection> typeProjections) {
+        for (Iterator<TypeProjection> iterator = typeProjections.iterator(); iterator.hasNext(); ) {
+            TypeProjection typeProjection = iterator.next();
+            if (typeProjection.getProjectionKind() != Variance.INVARIANT) {
+                result.append(typeProjection.getProjectionKind()).append(" ");
+            }
+            result.append(renderType(typeProjection.getType()));
+            if (iterator.hasNext()) {
+                result.append(", ");
+            }
+        }
+    }
+
     protected String renderTupleType(JetType type) {
         StringBuilder sb = new StringBuilder("#(");
         appendTypes(sb, JetStandardClasses.getTupleElementTypes(type));
@@ -129,7 +158,7 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
         }
 
         sb.append("(");
-        appendTypes(sb, JetStandardClasses.getParameterTypesFromFunctionType(type));
+        appendTypeProjections(sb, JetStandardClasses.getParameterTypeProjectionsFromFunctionType(type));
         sb.append(") -> ");
         sb.append(renderType(JetStandardClasses.getReturnTypeFromFunctionType(type)));