DescriptorRenderer can now render flexible types for code (i.e. ft<L, U>)

core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRenderer.java

@@ -62,6 +62,10 @@ public interface DescriptorRenderer extends Renderer<DeclarationDescriptor> {
 
     DescriptorRenderer DEBUG_TEXT = new DescriptorRendererBuilder().setDebugMode(true).build();
 
+    DescriptorRenderer FLEXIBLE_TYPES_FOR_CODE = new DescriptorRendererBuilder()
+            .setFlexibleTypesForCode(true)
+            .build();
+
     DescriptorRenderer HTML_COMPACT_WITH_MODIFIERS = new DescriptorRendererBuilder()
             .setWithDefinedIn(false)
             .setTextFormat(TextFormat.HTML).build();

core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRendererBuilder.java

@@ -52,6 +52,7 @@ public class DescriptorRendererBuilder {
         }
     };
     private boolean renderDefaultValues = true;
+    private boolean flexibleTypesForCode = false;
 
     @NotNull
     private DescriptorRenderer.OverrideRenderingPolicy overrideRenderingPolicy = DescriptorRenderer.OverrideRenderingPolicy.RENDER_OPEN;
@@ -221,6 +222,11 @@ public class DescriptorRendererBuilder {
         return this;
     }
 
+    public DescriptorRendererBuilder setFlexibleTypesForCode(boolean flexibleTypesForCode) {
+        this.flexibleTypesForCode = flexibleTypesForCode;
+        return this;
+    }
+
     @NotNull
     public DescriptorRenderer build() {
         return new DescriptorRendererImpl(
@@ -228,7 +234,7 @@ public class DescriptorRendererBuilder {
                 normalizedVisibilities, showInternalKeyword, prettyFunctionTypes, uninferredTypeParameterAsName,
                 overrideRenderingPolicy, valueParametersHandler, textFormat, excludedAnnotationClasses, includePropertyConstant,
                 includeSynthesizedParameterNames, withoutFunctionParameterNames, withoutTypeParameters, receiverAfterName,
-                renderClassObjectName, withoutSuperTypes, typeNormalizer, renderDefaultValues);
+                renderClassObjectName, withoutSuperTypes, typeNormalizer, renderDefaultValues, flexibleTypesForCode);
     }
 
 }

core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRendererImpl.java

@@ -46,6 +46,7 @@ import static org.jetbrains.jet.lang.types.TypeUtils.CANT_INFER_LAMBDA_PARAM_TYP
 import static org.jetbrains.jet.lang.types.TypeUtils.DONT_CARE;
 
 public class DescriptorRendererImpl implements DescriptorRenderer {
+
     private final Function1<JetType, JetType> typeNormalizer;
     private final boolean shortNames;
     private final boolean withDefinedIn;
@@ -66,6 +67,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer {
     private final boolean withoutSuperTypes;
     private final boolean receiverAfterName;
     private final boolean renderDefaultValues;
+    private final boolean flexibleTypesForCode;
 
     @NotNull
     private final OverrideRenderingPolicy overrideRenderingPolicy;
@@ -102,7 +104,8 @@ public class DescriptorRendererImpl implements DescriptorRenderer {
             boolean renderClassObjectName,
             boolean withoutSuperTypes,
             @NotNull Function1<JetType, JetType> typeNormalizer,
-            boolean renderDefaultValues
+            boolean renderDefaultValues,
+            boolean flexibleTypesForCode
     ) {
         this.shortNames = shortNames;
         this.withDefinedIn = withDefinedIn;
@@ -129,6 +132,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer {
         this.withoutSuperTypes = withoutSuperTypes;
         this.typeNormalizer = typeNormalizer;
         this.renderDefaultValues = renderDefaultValues;
+        this.flexibleTypesForCode = flexibleTypesForCode;
     }
 
     /* FORMATTING */
@@ -305,17 +309,29 @@ public class DescriptorRendererImpl implements DescriptorRenderer {
     @NotNull
     private String renderNormalizedType(@NotNull JetType type) {
         if (TypesPackage.isFlexible(type)) {
-            if (!debugMode) {
+            if (debugMode) {
-                return renderFlexibleType(type);
+                return renderFlexibleTypeWithBothBounds(TypesPackage.flexibility(type).getLowerBound(),
+                                                        TypesPackage.flexibility(type).getUpperBound());
+            }
+            else if (flexibleTypesForCode) {
+                String prefix = shortNames ? "" : Flexibility.FLEXIBLE_TYPE_CLASSIFIER.getPackageFqName().asString() + ".";
+                return prefix + Flexibility.FLEXIBLE_TYPE_CLASSIFIER.getRelativeClassName()
+                       + lt()
+                       + renderNormalizedType(TypesPackage.flexibility(type).getLowerBound()) + ", "
+                       + renderNormalizedType(TypesPackage.flexibility(type).getUpperBound())
+                       + gt();
             }
             else {
-                return "(" + renderNormalizedType(TypesPackage.flexibility(type).getLowerBound()) + ".." +
+                return renderFlexibleType(type);
-                             renderNormalizedType(TypesPackage.flexibility(type).getUpperBound()) + ")";
             }
         }
         return renderInflexibleType(type);
     }
 
+    private String renderFlexibleTypeWithBothBounds(@NotNull JetType lower, @NotNull JetType upper) {
+        return "(" + renderNormalizedType(lower) + ".." + renderNormalizedType(upper) + ")";
+    }
+
     private String renderInflexibleType(@NotNull JetType type) {
         assert !TypesPackage.isFlexible(type) : "Flexible types not allowed here: " + renderNormalizedType(type);
 
@@ -376,7 +392,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer {
                 kotlinPrefix + escape("Array<(out) ")
         );
         if (array != null) return array;
-        return "(" + renderNormalizedType(lower) + ".." + renderNormalizedType(upper) + ")";
+        return renderFlexibleTypeWithBothBounds(lower, upper);
     }
 
     @Nullable