Implement rendering of raw types

Also add some clarification in spec

compiler/testData/diagnostics/tests/generics/PseudoRawTypes.txt

@@ -6,7 +6,7 @@ package test {
     public open class Usage {
         public constructor Usage()
         public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-        public/*package*/ open fun foo(/*0*/ c: (kotlin.MutableCollection<kotlin.Any?>..kotlin.Collection<*>?)): kotlin.Unit
+        public/*package*/ open fun foo(/*0*/ c: kotlin.(Mutable)Collection<(raw) kotlin.Any?>!): kotlin.Unit
         public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
         public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
     }

compiler/testData/diagnostics/tests/j+k/overrideRawType.txt

@@ -1,10 +1,10 @@
 package
 
-public /*synthesized*/ fun Bar(/*0*/ function: ((Foo<kotlin.CharSequence!>..Foo<*>?)) -> kotlin.Unit): Bar
+public /*synthesized*/ fun Bar(/*0*/ function: (Foo<(raw) kotlin.CharSequence!>!) -> kotlin.Unit): Bar
 
 public interface Bar {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public abstract fun f(/*0*/ f: (Foo<kotlin.CharSequence!>..Foo<*>?)): kotlin.Unit
+    public abstract fun f(/*0*/ f: Foo<(raw) kotlin.CharSequence!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound.txt

@@ -1,9 +1,9 @@
 package
 
-internal fun foo(/*0*/ p: X): (Bad<Bad<*>!>..Bad<out Bad<*>!>?)
+internal fun foo(/*0*/ p: X): Bad<(raw) Bad<*>!>!
 
-public/*package*/ open class Bad</*0*/ T : (Bad<Bad<*>>..Bad<out Bad<*>>?)> {
+public/*package*/ open class Bad</*0*/ T : Bad<(raw) Bad<*>>!> {
-    public/*package*/ constructor Bad</*0*/ T : (Bad<Bad<*>>..Bad<out Bad<*>>?)>()
+    public/*package*/ constructor Bad</*0*/ T : Bad<(raw) Bad<*>>!>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -12,7 +12,7 @@ public/*package*/ open class Bad</*0*/ T : (Bad<Bad<*>>..Bad<out Bad<*>>?)> {
 public/*package*/ open class X {
     public/*package*/ constructor X()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public/*package*/ open fun foo(): (Bad<Bad<*>!>..Bad<out Bad<*>!>?)
+    public/*package*/ open fun foo(): Bad<(raw) Bad<*>!>!
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.txt

@@ -23,16 +23,16 @@ public/*package*/ open class Test {
 
     public/*package*/ open class RawADerived : A<kotlin.CharSequence!, kotlin.Any!> {
         public/*package*/ constructor RawADerived()
-        public/*package*/ final override /*1*/ /*fake_override*/ var arraysOfAny: kotlin.Array<(out) kotlin.Array<(out) kotlin.Any!>!>!
+        public/*package*/ final override /*1*/ /*fake_override*/ var arraysOfAny: kotlin.Array<(out) kotlin.Array<(out) kotlin.Any(raw)!>!>!
-        public/*package*/ final override /*1*/ /*fake_override*/ var arraysOfLists: kotlin.Array<(out) kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!>!
+        public/*package*/ final override /*1*/ /*fake_override*/ var arraysOfLists: kotlin.Array<(out) kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!>!
-        public/*package*/ final override /*1*/ /*fake_override*/ var charSequences: kotlin.Array<(out) kotlin.CharSequence!>!
+        public/*package*/ final override /*1*/ /*fake_override*/ var charSequences: kotlin.Array<(out) kotlin.CharSequence(raw)!>!
-        public/*package*/ final override /*1*/ /*fake_override*/ var erasedLists: kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!
+        public/*package*/ final override /*1*/ /*fake_override*/ var erasedLists: kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!
-        public/*package*/ final override /*1*/ /*fake_override*/ var maps: kotlin.Array<(out) (kotlin.MutableMap<kotlin.Any?, kotlin.Any?>..kotlin.Map<*, *>?)>!
+        public/*package*/ final override /*1*/ /*fake_override*/ var maps: kotlin.Array<(out) kotlin.(Mutable)Map<(raw) kotlin.Any?, (raw) kotlin.Any?>!>!
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
     }
 
     // Static members
-    public/*package*/ final var rawAField: (A<kotlin.CharSequence!, kotlin.Any!>..A<*, *>?)
+    public/*package*/ final var rawAField: A<(raw) kotlin.CharSequence!, (raw) kotlin.Any!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.txt

@@ -27,5 +27,5 @@ public/*package*/ open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    public/*package*/ final var rawAField: (A<kotlin.Any!>..A<*>?)
+    public/*package*/ final var rawAField: A<(raw) kotlin.Any!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt

@@ -18,6 +18,7 @@ class B {
 // FILE: Test.java
 
 class Test {
+    static class RawADerived extends A {}
     static A rawAField = null;
 }
 

compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.txt

@@ -25,6 +25,14 @@ public/*package*/ open class Test {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
+    public/*package*/ open class RawADerived : A<kotlin.Any!> {
+        public/*package*/ constructor RawADerived()
+        public/*package*/ final override /*1*/ /*fake_override*/ var b: B(raw)!
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
+    }
+
     // Static members
-    public/*package*/ final var rawAField: (A<kotlin.Any!>..A<*>?)
+    public/*package*/ final var rawAField: A<(raw) kotlin.Any!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonTrivialErasure.txt

@@ -3,8 +3,8 @@ package
 internal val strList: kotlin.List<kotlin.String>
 internal fun main(): kotlin.Unit
 
-public/*package*/ open class A</*0*/ T : (A<A<*, *, *>, A<*, *, *>, kotlin.(Mutable)List<*>!>..A<out A<*, *, *>, out A<*, *, *>, out kotlin.(Mutable)List<*>!>?), /*1*/ E : T!, /*2*/ F : (kotlin.MutableList<out kotlin.Double!>..kotlin.List<kotlin.Double!>?)> {
+public/*package*/ open class A</*0*/ T : A<(raw) A<*, *, *>, (raw) A<*, *, *>, (raw) kotlin.(Mutable)List<*>!>!, /*1*/ E : T!, /*2*/ F : (kotlin.MutableList<out kotlin.Double!>..kotlin.List<kotlin.Double!>?)> {
-    public/*package*/ constructor A</*0*/ T : (A<A<*, *, *>, A<*, *, *>, kotlin.(Mutable)List<*>!>..A<out A<*, *, *>, out A<*, *, *>, out kotlin.(Mutable)List<*>!>?), /*1*/ E : T!, /*2*/ F : (kotlin.MutableList<out kotlin.Double!>..kotlin.List<kotlin.Double!>?)>()
+    public/*package*/ constructor A</*0*/ T : A<(raw) A<*, *, *>, (raw) A<*, *, *>, (raw) kotlin.(Mutable)List<*>!>!, /*1*/ E : T!, /*2*/ F : (kotlin.MutableList<out kotlin.Double!>..kotlin.List<kotlin.Double!>?)>()
     public/*package*/ final var first: T!
     public/*package*/ final var listOfDoubles: F!
     public/*package*/ final var second: E!
@@ -21,14 +21,14 @@ public/*package*/ open class Test {
 
     public/*package*/ open class DerivedRawA : A<out A<*, *, *>!, out A<*, *, *>!, out kotlin.(Mutable)List<*>!> {
         public/*package*/ constructor DerivedRawA()
-        public/*package*/ final override /*1*/ /*fake_override*/ var first: (A<A<*, *, *>!, A<*, *, *>!, kotlin.(Mutable)List<*>!>..A<out A<*, *, *>!, out A<*, *, *>!, out kotlin.(Mutable)List<*>!>?)
+        public/*package*/ final override /*1*/ /*fake_override*/ var first: A<(raw) A<*, *, *>!, (raw) A<*, *, *>!, (raw) kotlin.(Mutable)List<*>!>!
-        public/*package*/ final override /*1*/ /*fake_override*/ var listOfDoubles: (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)
+        public/*package*/ final override /*1*/ /*fake_override*/ var listOfDoubles: kotlin.(Mutable)List<(raw) kotlin.Any?>!
-        public/*package*/ final override /*1*/ /*fake_override*/ var second: (A<A<*, *, *>!, A<*, *, *>!, kotlin.(Mutable)List<*>!>..A<out A<*, *, *>!, out A<*, *, *>!, out kotlin.(Mutable)List<*>!>?)
+        public/*package*/ final override /*1*/ /*fake_override*/ var second: A<(raw) A<*, *, *>!, (raw) A<*, *, *>!, (raw) kotlin.(Mutable)List<*>!>!
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
     }
 
     // Static members
-    public/*package*/ final var rawAField: (A<A<*, *, *>!, A<*, *, *>!, kotlin.(Mutable)List<*>!>..A<out A<*, *, *>!, out A<*, *, *>!, out kotlin.(Mutable)List<*>!>?)
+    public/*package*/ final var rawAField: A<(raw) A<*, *, *>!, (raw) A<*, *, *>!, (raw) kotlin.(Mutable)List<*>!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.txt

@@ -22,11 +22,11 @@ public/*package*/ open class Test {
 
     public/*package*/ open class RawADerived : A<kotlin.Any!> {
         public/*package*/ constructor RawADerived()
-        public/*package*/ final override /*1*/ /*fake_override*/ var x: (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)
+        public/*package*/ final override /*1*/ /*fake_override*/ var x: kotlin.(Mutable)List<(raw) kotlin.Any?>!
-        public/*package*/ open override /*1*/ /*fake_override*/ fun bar(): (A<kotlin.Any!>..A<*>?)
+        public/*package*/ open override /*1*/ /*fake_override*/ fun bar(): A<(raw) kotlin.Any!>!
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
-        public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.Any!, /*1*/ y: (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)): kotlin.Unit
+        public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.Any(raw)!, /*1*/ y: kotlin.(Mutable)List<(raw) kotlin.Any?>!): kotlin.Unit(raw)
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
     }
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertypeOverride.txt

@@ -12,46 +12,46 @@ public/*package*/ open class A</*0*/ T : kotlin.CharSequence!> {
 internal final class B1 : RawADerived {
     public constructor B1()
     internal open override /*1*/ fun bar(/*0*/ d: kotlin.Array<kotlin.Array<kotlin.List<*>>>): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
     internal open override /*1*/ fun foo(/*0*/ x: kotlin.CharSequence, /*1*/ y: kotlin.Map<kotlin.Any?, kotlin.Any?>, /*2*/ z: java.util.HashMap<kotlin.Any, kotlin.Any>): A<*>
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
 }
 
 internal final class B2 : RawADerived {
     public constructor B2()
     internal open override /*1*/ fun bar(/*0*/ d: kotlin.Array<kotlin.Array<kotlin.MutableList<*>>>): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
     internal open override /*1*/ fun foo(/*0*/ x: kotlin.CharSequence?, /*1*/ y: kotlin.MutableMap<kotlin.Any?, kotlin.Any?>, /*2*/ z: java.util.HashMap<kotlin.Any?, kotlin.Any?>): A<kotlin.String>
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
 }
 
 internal final class B3 : RawADerived {
     public constructor B3()
-    public/*package*/ open override /*1*/ /*fake_override*/ fun bar(/*0*/ d: kotlin.Array<(out) kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!>!): kotlin.Unit
+    public/*package*/ open override /*1*/ /*fake_override*/ fun bar(/*0*/ d: kotlin.Array<(out) kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!>!): kotlin.Unit(raw)
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
     internal open fun foo(/*0*/ x: kotlin.CharSequence, /*1*/ y: kotlin.Map<kotlin.Any?, kotlin.Any>, /*2*/ z: java.util.HashMap<kotlin.Any, kotlin.Any>): A<*>
-    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.CharSequence!, /*1*/ y: (kotlin.MutableMap<kotlin.Any?, kotlin.Any?>..kotlin.Map<*, *>?), /*2*/ z: (java.util.HashMap<kotlin.Any!, kotlin.Any!>..java.util.HashMap<*, *>?)): (A<kotlin.CharSequence!>..A<*>?)
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.CharSequence(raw)!, /*1*/ y: kotlin.(Mutable)Map<(raw) kotlin.Any?, (raw) kotlin.Any?>!, /*2*/ z: java.util.HashMap<(raw) kotlin.Any!, (raw) kotlin.Any!>!): A<(raw) kotlin.CharSequence!>!
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
 }
 
 internal final class B4 : RawADerived {
     public constructor B4()
-    public/*package*/ open override /*1*/ /*fake_override*/ fun bar(/*0*/ d: kotlin.Array<(out) kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!>!): kotlin.Unit
+    public/*package*/ open override /*1*/ /*fake_override*/ fun bar(/*0*/ d: kotlin.Array<(out) kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!>!): kotlin.Unit(raw)
     internal open fun bar(/*0*/ d: kotlin.Array<kotlin.Array<kotlin.MutableList<kotlin.Array<kotlin.Double>>>>): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
-    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.CharSequence!, /*1*/ y: (kotlin.MutableMap<kotlin.Any?, kotlin.Any?>..kotlin.Map<*, *>?), /*2*/ z: (java.util.HashMap<kotlin.Any!, kotlin.Any!>..java.util.HashMap<*, *>?)): (A<kotlin.CharSequence!>..A<*>?)
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.CharSequence(raw)!, /*1*/ y: kotlin.(Mutable)Map<(raw) kotlin.Any?, (raw) kotlin.Any?>!, /*2*/ z: java.util.HashMap<(raw) kotlin.Any!, (raw) kotlin.Any!>!): A<(raw) kotlin.CharSequence!>!
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
 }
 
 public/*package*/ open class RawADerived : A<kotlin.CharSequence!> {
     public/*package*/ constructor RawADerived()
-    public/*package*/ open override /*1*/ /*fake_override*/ fun bar(/*0*/ d: kotlin.Array<(out) kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!>!): kotlin.Unit
+    public/*package*/ open override /*1*/ /*fake_override*/ fun bar(/*0*/ d: kotlin.Array<(out) kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!>!): kotlin.Unit(raw)
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
-    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.CharSequence!, /*1*/ y: (kotlin.MutableMap<kotlin.Any?, kotlin.Any?>..kotlin.Map<*, *>?), /*2*/ z: (java.util.HashMap<kotlin.Any!, kotlin.Any!>..java.util.HashMap<*, *>?)): (A<kotlin.CharSequence!>..A<*>?)
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.CharSequence(raw)!, /*1*/ y: kotlin.(Mutable)Map<(raw) kotlin.Any?, (raw) kotlin.Any?>!, /*2*/ z: java.util.HashMap<(raw) kotlin.Any!, (raw) kotlin.Any!>!): A<(raw) kotlin.CharSequence!>!
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.txt

@@ -12,8 +12,8 @@ public open class A</*0*/ T : kotlin.Any!> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class B</*0*/ E : (A<kotlin.Any!>..A<*>?)> {
+public open class B</*0*/ E : A<(raw) kotlin.Any!>!> {
-    public constructor B</*0*/ E : (A<kotlin.Any!>..A<*>?)>()
+    public constructor B</*0*/ E : A<(raw) kotlin.Any!>!>()
     public/*package*/ final var field: E!
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open fun foo(): E!
@@ -28,5 +28,5 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    public/*package*/ final var rawB: (B<A<*>!>..B<out A<*>!>?)
+    public/*package*/ final var rawB: B<(raw) A<*>!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawWithInProjection.txt

@@ -9,5 +9,5 @@ public/*package*/ open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    public/*package*/ open fun foo(/*0*/ x: (kotlin.Comparable<kotlin.Any?>..kotlin.Comparable<kotlin.Nothing>?)): kotlin.Unit
+    public/*package*/ open fun foo(/*0*/ x: (kotlin.Comparable<(raw) kotlin.Any?>..kotlin.Comparable<kotlin.Nothing>?)): kotlin.Unit
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/recursiveBound.txt

@@ -2,7 +2,7 @@ package
 
 internal fun main(/*0*/ x: A<*>): kotlin.Unit
 
-public interface A</*0*/ T : (A<A<*>>..A<out A<*>>?)> {
+public interface A</*0*/ T : A<(raw) A<*>>!> {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String

compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.txt

@@ -13,10 +13,10 @@ public interface A</*0*/ T : kotlin.Any!> {
 public/*package*/ open class B {
     public/*package*/ constructor B()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public/*package*/ open fun foo(/*0*/ runnable: java.lang.Runnable!, /*1*/ x: (A<kotlin.Any!>..A<*>?)): kotlin.Unit
+    public/*package*/ open fun foo(/*0*/ runnable: java.lang.Runnable!, /*1*/ x: A<(raw) kotlin.Any!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    public/*package*/ open fun bar(): (A<kotlin.Any!>..A<*>?)
+    public/*package*/ open fun bar(): A<(raw) kotlin.Any!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.txt

@@ -23,5 +23,5 @@ public/*package*/ open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    public/*package*/ final var rawAField: (A<kotlin.Any!>..A<*>?)
+    public/*package*/ final var rawAField: A<(raw) kotlin.Any!>!
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/starProjectionToRaw.txt

@@ -9,8 +9,8 @@ public/*package*/ open class A</*0*/ T : kotlin.CharSequence!> {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public/*package*/ open class B</*0*/ E : (A<kotlin.CharSequence!>..A<*>?)> {
+public/*package*/ open class B</*0*/ E : A<(raw) kotlin.CharSequence!>!> {
-    public/*package*/ constructor B</*0*/ E : (A<kotlin.CharSequence!>..A<*>?)>()
+    public/*package*/ constructor B</*0*/ E : A<(raw) kotlin.CharSequence!>!>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -23,5 +23,5 @@ public/*package*/ open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 
     // Static members
-    public/*package*/ open fun foo(/*0*/ x: (B<A<*>!>..B<out A<*>!>?)): kotlin.Unit
+    public/*package*/ open fun foo(/*0*/ x: B<(raw) A<*>!>!): kotlin.Unit
 }

compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.txt

@@ -19,12 +19,12 @@ public/*package*/ open class Test {
 
     public/*package*/ open class DerivedRawA : A<kotlin.Any!> {
         public/*package*/ constructor DerivedRawA()
-        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any(raw)?): kotlin.Boolean(raw)
-        org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.Any, /*1*/ org.jetbrains.annotations.Nullable() y: (kotlin.MutableList<kotlin.Any?>?..kotlin.List<*>?)): (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>)
+        org.jetbrains.annotations.NotNull() public/*package*/ open override /*1*/ /*fake_override*/ fun foo(/*0*/ org.jetbrains.annotations.NotNull() x: kotlin.Any(raw), /*1*/ org.jetbrains.annotations.Nullable() y: kotlin.(Mutable)List<(raw) kotlin.Any?>?): kotlin.(Mutable)List<(raw) kotlin.Any?>
-        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int(raw)
-        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String(raw)
     }
 
     // Static members
-    public/*package*/ final var rawField: (A<kotlin.Any!>..A<*>?)
+    public/*package*/ final var rawField: A<(raw) kotlin.Any!>!
 }

compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.txt

@@ -37,7 +37,7 @@ package test {
         invisible_fake final override /*1*/ /*fake_override*/ var focusCycleRoot: kotlin.Boolean
         invisible_fake final override /*1*/ /*fake_override*/ var focusListener: [ERROR : Unresolved java classifier: FocusListener]!
         invisible_fake final override /*1*/ /*fake_override*/ var focusMgr: [ERROR : Unresolved java classifier: FocusManager]!
-        invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalKeys: kotlin.Array<(out) (kotlin.MutableSet<kotlin.Any?>..kotlin.Set<*>?)>!
+        invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalKeys: kotlin.Array<(out) kotlin.(Mutable)Set<(raw) kotlin.Any?>!>!
         invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalKeysEnabled: kotlin.Boolean
         invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalPolicy: [ERROR : Unresolved java classifier: FocusTraversalPolicy]!
         invisible_fake final override /*1*/ /*fake_override*/ var focusTraversalPolicyProvider: kotlin.Boolean
@@ -98,7 +98,7 @@ package test {
         invisible_fake final override /*1*/ /*fake_override*/ var prefSizeSet: kotlin.Boolean
         invisible_fake final override /*1*/ /*fake_override*/ var preserveBackgroundColor: [ERROR : Unresolved java classifier: Color]!
         invisible_fake final override /*1*/ /*fake_override*/ var printing: kotlin.Boolean
-        invisible_fake final override /*1*/ /*fake_override*/ var printingThreads: (kotlin.MutableSet<kotlin.Any?>..kotlin.Set<*>?)
+        invisible_fake final override /*1*/ /*fake_override*/ var printingThreads: kotlin.(Mutable)Set<(raw) kotlin.Any?>!
         invisible_fake final override /*1*/ /*fake_override*/ var resizable: kotlin.Boolean
         protected/*protected and package*/ final override /*1*/ /*fake_override*/ var rootPane: [ERROR : Unresolved java classifier: JRootPane]!
         protected/*protected and package*/ final override /*1*/ /*fake_override*/ var rootPaneCheckingEnabled: kotlin.Boolean
@@ -290,7 +290,7 @@ package test {
         public open override /*1*/ /*fake_override*/ fun getFocusOwner(): java.awt.Component!
         public open override /*1*/ /*fake_override*/ fun getFocusTraversalKeys(/*0*/ p0: kotlin.Int): kotlin.(Mutable)Set<java.awt.AWTKeyStroke!>!
         public open override /*1*/ /*fake_override*/ fun getFocusTraversalKeysEnabled(): kotlin.Boolean
-        invisible_fake final override /*1*/ /*fake_override*/ fun getFocusTraversalKeys_NoIDCheck(/*0*/ p0: kotlin.Int): (kotlin.MutableSet<kotlin.Any?>..kotlin.Set<*>?)
+        invisible_fake final override /*1*/ /*fake_override*/ fun getFocusTraversalKeys_NoIDCheck(/*0*/ p0: kotlin.Int): kotlin.(Mutable)Set<(raw) kotlin.Any?>!
         public open override /*1*/ /*fake_override*/ fun getFocusTraversalPolicy(): [ERROR : Unresolved java classifier: FocusTraversalPolicy]!
         public open override /*1*/ /*fake_override*/ fun getFocusableWindowState(): kotlin.Boolean
         [ERROR : java.beans.Transient]() public open override /*1*/ /*fake_override*/ fun getFont(): [ERROR : Unresolved java classifier: Font]!

compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.txt

@@ -3,8 +3,8 @@ package test
 public interface RawTypeWithUpperBound {
 
     public interface Bar {
-        public abstract fun f(/*0*/ p0: (test.RawTypeWithUpperBound.Foo<kotlin.CharSequence!>..test.RawTypeWithUpperBound.Foo<*>?)): kotlin.Unit
+        public abstract fun f(/*0*/ p0: test.RawTypeWithUpperBound.Foo<(raw) kotlin.CharSequence!>!): kotlin.Unit
-        public abstract fun g(/*0*/ p0: kotlin.(Mutable)List<(test.RawTypeWithUpperBound.Foo<kotlin.CharSequence!>..test.RawTypeWithUpperBound.Foo<*>?)>!): kotlin.Unit
+        public abstract fun g(/*0*/ p0: kotlin.(Mutable)List<test.RawTypeWithUpperBound.Foo<(raw) kotlin.CharSequence!>!>!): kotlin.Unit
     }
 
     public interface Foo</*0*/ T : kotlin.CharSequence!> {

compiler/testData/loadJava/compiledJava/RawUpperBound.txt

@@ -1,4 +1,4 @@
 package test
 
-public interface RawUpperBound</*0*/ T : (test.RawUpperBound<test.RawUpperBound<*>>..test.RawUpperBound<out test.RawUpperBound<*>>?)> {
+public interface RawUpperBound</*0*/ T : test.RawUpperBound<(raw) test.RawUpperBound<*>>!> {
 }

compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.txt

@@ -1,4 +1,4 @@
 package test
 
-public interface RecursiveRawUpperBound</*0*/ T : (test.RecursiveRawUpperBound<test.RecursiveRawUpperBound<*>>..test.RecursiveRawUpperBound<out test.RecursiveRawUpperBound<*>>?)> {
+public interface RecursiveRawUpperBound</*0*/ T : test.RecursiveRawUpperBound<(raw) test.RecursiveRawUpperBound<*>>!> {
 }

compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.txt

@@ -1,4 +1,4 @@
 package test
 
-public interface RecursiveWildcardUpperBound</*0*/ T : (test.RecursiveWildcardUpperBound<test.RecursiveWildcardUpperBound<*>>..test.RecursiveWildcardUpperBound<out test.RecursiveWildcardUpperBound<*>>?)> {
+public interface RecursiveWildcardUpperBound</*0*/ T : test.RecursiveWildcardUpperBound<(raw) test.RecursiveWildcardUpperBound<*>>!> {
 }

compiler/testData/loadJava/compiledJava/rendering/Rendering.txt

@@ -42,8 +42,8 @@ public open class Rendering {
     }
 
     public/*package*/ interface H_Raw {
-        public abstract fun foo1(/*0*/ p0: (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)): kotlin.Unit
+        public abstract fun foo1(/*0*/ p0: kotlin.(Mutable)List<(raw) kotlin.Any?>!): kotlin.Unit
-        public abstract fun foo2(/*0*/ p0: (test.Rendering.D_SuperG<kotlin.Any!>..test.Rendering.D_SuperG<*>?)): kotlin.Unit
+        public abstract fun foo2(/*0*/ p0: test.Rendering.D_SuperG<(raw) kotlin.Any!>!): kotlin.Unit
     }
 
     public/*package*/ interface I_Wildcard {

compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBound.txt

@@ -6,8 +6,8 @@ public open class RawSuperTypeWithRecursiveBound {
     public open inner class Derived : test.RawSuperTypeWithRecursiveBound.Super<out test.RawSuperTypeWithRecursiveBound.Super<*>!> {
         public constructor Derived()
         public open override /*1*/ fun dummy(): kotlin.Unit
-        public open override /*1*/ fun foo(/*0*/ p0: (test.RawSuperTypeWithRecursiveBound.Super<test.RawSuperTypeWithRecursiveBound.Super<*>!>..test.RawSuperTypeWithRecursiveBound.Super<out test.RawSuperTypeWithRecursiveBound.Super<*>!>?)): kotlin.Unit
         public open fun foo(/*0*/ p0: kotlin.Any!): kotlin.Unit
+        public open override /*1*/ fun foo(/*0*/ p0: test.RawSuperTypeWithRecursiveBound.Super<(raw) test.RawSuperTypeWithRecursiveBound.Super<*>!>!): kotlin.Unit
     }
 
     public interface Super</*0*/ T : test.RawSuperTypeWithRecursiveBound.Super<T!>!> {

compiler/testData/loadJava/compiledJava/signaturePropagation/RawSuperTypeWithRecursiveBoundMultipleParameters.txt

@@ -6,8 +6,8 @@ public open class RawSuperTypeWithRecursiveBoundMultipleParameters {
     public open inner class Derived : test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<kotlin.Any!, out test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, *>!> {
         public constructor Derived()
         public open override /*1*/ fun dummy(): kotlin.Unit
-        public open override /*1*/ fun foo(/*0*/ p0: kotlin.Any!, /*1*/ p1: (test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<kotlin.Any!, test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, *>!>..test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, out test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, *>!>?)): kotlin.Unit
         public open fun foo(/*0*/ p0: kotlin.Any!, /*1*/ p1: kotlin.Any!): kotlin.Unit
+        public open override /*1*/ fun foo(/*0*/ p0: kotlin.Any!, /*1*/ p1: test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<(raw) kotlin.Any!, (raw) test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<*, *>!>!): kotlin.Unit
     }
 
     public interface Super</*0*/ R : kotlin.Any!, /*1*/ T : test.RawSuperTypeWithRecursiveBoundMultipleParameters.Super<R!, T!>!> {

compiler/testData/loadJava/compiledJava/signaturePropagation/SubclassWithRawType.txt

@@ -4,22 +4,22 @@ public interface SubclassWithRawType {
 
     public interface Sub : test.SubclassWithRawType.Super {
         public abstract override /*1*/ fun array1(): kotlin.Array<(out) kotlin.(Mutable)List<kotlin.String!>!>!
-        public abstract override /*1*/ fun array2(): kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!
+        public abstract override /*1*/ fun array2(): kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!
         public abstract override /*1*/ fun boundWildcard1(): (kotlin.MutableList<out kotlin.(Mutable)List<kotlin.String!>!>..kotlin.List<kotlin.(Mutable)List<kotlin.String!>!>?)
-        public abstract override /*1*/ fun boundWildcard2(): kotlin.(Mutable)List<in (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!
+        public abstract override /*1*/ fun boundWildcard2(): kotlin.(Mutable)List<in kotlin.(Mutable)List<(raw) kotlin.Any?>!>!
         public abstract override /*1*/ fun simple1(): kotlin.(Mutable)List<kotlin.String!>!
         public abstract override /*1*/ fun simple2(): kotlin.(Mutable)List<kotlin.(Mutable)List<kotlin.String!>!>!
-        public abstract override /*1*/ fun simple3(): (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)
+        public abstract override /*1*/ fun simple3(): kotlin.(Mutable)List<(raw) kotlin.Any?>!
-        public abstract override /*1*/ fun wildcard(): (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)
+        public abstract override /*1*/ fun wildcard(): kotlin.(Mutable)List<(raw) kotlin.Any?>!
     }
 
     public interface Super {
-        public abstract fun array1(): kotlin.Array<(out) (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>!
+        public abstract fun array1(): kotlin.Array<(out) kotlin.(Mutable)List<(raw) kotlin.Any?>!>!
         public abstract fun array2(): kotlin.Array<(out) kotlin.(Mutable)List<kotlin.String!>!>!
-        public abstract fun boundWildcard1(): (kotlin.MutableList<out (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>..kotlin.List<(kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)>?)
+        public abstract fun boundWildcard1(): (kotlin.MutableList<out kotlin.(Mutable)List<(raw) kotlin.Any?>!>..kotlin.List<kotlin.(Mutable)List<(raw) kotlin.Any?>!>?)
         public abstract fun boundWildcard2(): kotlin.(Mutable)List<in kotlin.(Mutable)List<kotlin.String!>!>!
-        public abstract fun simple1(): (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)
+        public abstract fun simple1(): kotlin.(Mutable)List<(raw) kotlin.Any?>!
-        public abstract fun simple2(): (kotlin.MutableList<kotlin.Any?>..kotlin.List<*>?)
+        public abstract fun simple2(): kotlin.(Mutable)List<(raw) kotlin.Any?>!
         public abstract fun simple3(): kotlin.(Mutable)List<kotlin.String!>!
         public abstract fun wildcard(): kotlin.(Mutable)List<*>!
     }

compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.txt

@@ -1,9 +1,9 @@
 package test
 
 public interface WrongNumberOfGenericParameters {
-    public abstract fun o0(): (test.WrongNumberOfGenericParameters.One<kotlin.Any!>..test.WrongNumberOfGenericParameters.One<*>?)
+    public abstract fun o0(): test.WrongNumberOfGenericParameters.One<(raw) kotlin.Any!>!
     public abstract fun o2(): test.WrongNumberOfGenericParameters.One<[ERROR : T]>!
-    public abstract fun t1(): (test.WrongNumberOfGenericParameters.Two<kotlin.Any!, kotlin.Any!>..test.WrongNumberOfGenericParameters.Two<*, *>?)
+    public abstract fun t1(): test.WrongNumberOfGenericParameters.Two<(raw) kotlin.Any!, (raw) kotlin.Any!>!
     public abstract fun z(): test.WrongNumberOfGenericParameters.Zero!
 
     public interface One</*0*/ T : kotlin.Any!> {

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/RawType.kt

@@ -20,6 +20,8 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.load.java.components.TypeUsage
+import org.jetbrains.kotlin.renderer.CustomFlexibleRendering
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.types.*
 
 public object RawTypeCapabilities : TypeCapabilities {
@@ -27,10 +29,49 @@ public object RawTypeCapabilities : TypeCapabilities {
         override val substitution = RawSubstitution
     }
 
+    private object RawFlexibleRendering : CustomFlexibleRendering {
+        private fun DescriptorRenderer.renderArguments(jetType: JetType) = jetType.arguments.map { renderTypeProjection(it) }
+
+        private fun String.replaceArgs(newArgs: String): String {
+            if (!contains('<')) return this
+            return "${substringBefore('<')}<$newArgs>${substringAfterLast('>')}"
+        }
+
+        override fun renderInflexible(type: JetType, renderer: DescriptorRenderer): String? {
+            if (type.arguments.isNotEmpty()) return null
+
+            return StringBuilder {
+                append(renderer.renderTypeConstructor(type.constructor))
+                append("(raw)")
+                if (type.isMarkedNullable) append('?')
+            }.toString()
+        }
+
+        override fun renderBounds(flexibility: Flexibility, renderer: DescriptorRenderer): Pair<String, String>? {
+            val lowerArgs = renderer.renderArguments(flexibility.lowerBound)
+            val upperArgs = renderer.renderArguments(flexibility.upperBound)
+
+            val lowerRendered = renderer.renderType(flexibility.lowerBound)
+            val upperRendered = renderer.renderType(flexibility.upperBound)
+
+            if (!upperArgs.isNotEmpty()) return null
+
+            val newArgs = lowerArgs.map { "(raw) $it" }.join(", ")
+            val newUpper =
+                    if (lowerArgs.zip(upperArgs).all { onlyOutDiffers(it.first, it.second) })
+                        upperRendered.replaceArgs(newArgs)
+                    else upperRendered
+            return Pair(lowerRendered.replaceArgs(newArgs), newUpper)
+        }
+
+        private fun onlyOutDiffers(first: String, second: String) = first == second.removePrefix("out ") || second == "*"
+    }
+
     override fun <T : TypeCapability> getCapability(capabilityClass: Class<T>): T? {
         @suppress("UNCHECKED_CAST")
         return when(capabilityClass) {
             javaClass<CustomSubstitutionCapability>() -> RawSubstitutionCapability as T
+            javaClass<CustomFlexibleRendering>() -> RawFlexibleRendering as T
             else -> null
         }
     }

core/descriptors/src/org/jetbrains/kotlin/renderer/CustomRendering.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.renderer
+
+import org.jetbrains.kotlin.types.Flexibility
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeCapability
+
+public interface CustomFlexibleRendering : TypeCapability {
+    public fun renderInflexible(type: JetType, renderer: DescriptorRenderer): String?
+    public fun renderBounds(flexibility: Flexibility, renderer: DescriptorRenderer): Pair<String, String>?
+}

core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameBase
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.TypeProjection
 
 public interface DescriptorRenderer : Renderer<DeclarationDescriptor> {
@@ -36,6 +37,10 @@ public interface DescriptorRenderer : Renderer<DeclarationDescriptor> {
 
     public fun renderTypeArguments(typeArguments: List<TypeProjection>): String
 
+    public fun renderTypeProjection(typeProjection: TypeProjection): String
+
+    public fun renderTypeConstructor(typeConstructor: TypeConstructor): String
+
     public fun renderClassifierName(klass: ClassifierDescriptor): String
 
     public fun renderAnnotation(annotation: AnnotationDescriptor): String

core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt

@@ -171,12 +171,17 @@ internal class DescriptorRendererImpl(
     }
 
     private fun renderFlexibleTypeWithBothBounds(lower: JetType, upper: JetType): String {
-        return "(" + renderNormalizedType(lower) + ".." + renderNormalizedType(upper) + ")"
+        return renderFlexibleTypeWithBothBounds(renderNormalizedType(lower), renderNormalizedType(upper))
     }
 
+    private fun renderFlexibleTypeWithBothBounds(lower: String, upper: String) = "($lower..$upper)"
+
     private fun renderInflexibleType(type: JetType): String {
         assert(!type.isFlexible()) { "Flexible types not allowed here: " + renderNormalizedType(type) }
 
+        val customResult = type.getCapability<CustomFlexibleRendering>()?.renderInflexible(type, this)
+        if (customResult != null) return customResult
+
         if (type == CANT_INFER_FUNCTION_PARAM_TYPE || TypeUtils.isDontCarePlaceholder(type)) {
             return "???"
         }
@@ -204,8 +209,8 @@ internal class DescriptorRendererImpl(
         val lower = type.flexibility().lowerBound
         val upper = type.flexibility().upperBound
 
-        val lowerRendered = renderInflexibleType(lower)
+        val (lowerRendered, upperRendered) = type.getCapability<CustomFlexibleRendering>()?.renderBounds(type.flexibility(), this)
-        val upperRendered = renderInflexibleType(upper)
+                                             ?: Pair(renderInflexibleType(lower), renderInflexibleType(upper))
 
         if (differsOnlyInNullability(lowerRendered, upperRendered)) {
             if (upperRendered.startsWith("(")) {
@@ -227,7 +232,7 @@ internal class DescriptorRendererImpl(
         // Foo[] -> Array<(out) Foo!>!
         val array = replacePrefixes(lowerRendered, kotlinPrefix + escape("Array<"), upperRendered, kotlinPrefix + escape("Array<out "), kotlinPrefix + escape("Array<(out) "))
         if (array != null) return array
-        return renderFlexibleTypeWithBothBounds(lower, upper)
+        return renderFlexibleTypeWithBothBounds(lowerRendered, upperRendered)
     }
 
     override fun renderTypeArguments(typeArguments: List<TypeProjection>): String {
@@ -248,7 +253,7 @@ internal class DescriptorRendererImpl(
             sb.append(type.getConstructor().toString()) // Debug name of an error type is more informative
         }
         else {
-            sb.append(renderTypeName(type.getConstructor()))
+            sb.append(renderTypeConstructor(type.getConstructor()))
         }
         sb.append(renderTypeArguments(type.getArguments()))
         if (type.isMarkedNullable()) {
@@ -257,7 +262,7 @@ internal class DescriptorRendererImpl(
         return sb.toString()
     }
 
-    private fun renderTypeName(typeConstructor: TypeConstructor): String {
+    override fun renderTypeConstructor(typeConstructor: TypeConstructor): String {
         val cd = typeConstructor.getDeclarationDescriptor()
         return when (cd) {
             is TypeParameterDescriptor -> renderName(cd.getName())
@@ -267,6 +272,10 @@ internal class DescriptorRendererImpl(
         }
     }
 
+    override fun renderTypeProjection(typeProjection: TypeProjection) = StringBuilder {
+        appendTypeProjections(listOf(typeProjection), this)
+    }.toString()
+
     private fun appendTypeProjections(typeProjections: List<TypeProjection>, builder: StringBuilder) {
         typeProjections.map {
             if (it.isStarProjection()) {

core/descriptors/src/org/jetbrains/kotlin/types/flexibleTypes.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.types
 
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
 import kotlin.platform.platformStatic
 

idea/testData/codeInsight/overrideImplement/implementJavaRawSubclass/foo/A.java

@@ -0,0 +1,5 @@
+package foo;
+
+public abstract class A implements B {
+
+}

idea/testData/codeInsight/overrideImplement/implementJavaRawSubclass/foo/B.java

@@ -0,0 +1,6 @@
+package foo;
+import java.util.*;
+
+public interface B<T> {
+    B<String> foo(List<String> x, String y);
+}

idea/testData/codeInsight/overrideImplement/implementJavaRawSubclass/foo/Impl.kt

@@ -0,0 +1,5 @@
+import foo.A
+
+class C : A() {
+    <caret>
+}

idea/testData/codeInsight/overrideImplement/implementJavaRawSubclass/foo/Impl.kt.after

@@ -0,0 +1,8 @@
+import foo.A
+import foo.B
+
+class C : A() {
+    override fun foo(x: MutableList<Any?>?, y: String?): B<*>? {
+        <selection><caret>throw UnsupportedOperationException()</selection>
+    }
+}

idea/tests/org/jetbrains/kotlin/idea/codeInsight/OverrideImplementTest.java

@@ -63,6 +63,10 @@ public final class OverrideImplementTest extends AbstractOverrideImplementTest {
         doImplementFileTest();
     }
 
+    public void testImplementJavaRawSubclass() {
+        doImplementDirectoryTest();
+    }
+
     public void testProperty() {
         doImplementFileTest();
     }

spec-docs/flexible-java-types.md

@@ -69,11 +69,17 @@ k(int[]) = IntArray
 Raw Java types (see https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.8 for clarification) are loaded as usual flexible types with special arguments projections.
 
 ```
-Raw(G<T1>..F<T2>) = (G<ErasedUpperBound(T1)>..F<out ErasedUpperBound(T2)>) // T1 and T2 have invariant or `out` variance
+Raw(G) = (G<ErasedUpperBound(T)>..G<out ErasedUpperBound(T)>?) // T is a generic parameter of G and it's invariant or has `out` variance.
-Raw(G<T1>..F<T2>) = (G<ErasedUpperBound(T1)>..F<Nothing>) // T1 and T2 have `in` variance
+                                                               // notation: G<(raw) ErasedUpperBound(T)>!
-```
 
-where `G<T1>..F<T2>` is initially loaded flexible type with yet unsubstituted type parameters.
+Raw(G) = (G<ErasedUpperBound(T1)>..G<Nothing>?)                // T is a generic parameter of G and it has `in` variance.
+
+Raw(java.util.Collection) = (MutableCollection<ErasedUpperBound(T)>..Collection<out ErasedUpperBound(T)?>)
+                                                               // notation: (Mutable)Collection<(raw) ErasedUpperBound(T)>!
+
+Raw(A) = (A..A?) // A has no generic parameter
+                 // notation: A(raw)!
+```
 
 `ErasedUpperBound` defined as follows:
 
@@ -90,22 +96,24 @@ that should be handled properly, e.g. by loading such ErasedUpperBound as Error
 Examples:
 
 ```
-Raw(java.util.concurrent.Future) = (Future<Any!>..Future<out Any!>?)
+Raw(java.util.concurrent.Future) = (Future<Any!>..Future<out Any!>?)         // notation: Future<(raw) Any!>!
-Raw(java.util.Collection) = (MutableCollection<Any?>..Collection<out Any?>?)
 
 class A<T extends CharSequence> {}
-Raw(A) = (A<CharSequence!>..A<out CharSequence>)
+Raw(A) = (A<CharSequence!>..A<out CharSequence>?) // notation: A<(raw) CharSequence!>!
 
-Raw(java.lang.Enum) = (Enum<Enum<*>>..Enum<out Enum<*>>?)
+Raw(java.lang.Enum) = (Enum<Enum<*>!>..Enum<out Enum<*>!>?) // notation: Enum<(raw) Enum<*>!>!
 ```
 
 Also raw types have special types of contained members, each of them is replaced with it's JVM erasure representation:
 
 ```
 Erase(T) = Erase(UpperBound(T)) // T is a type variable
-Erase(Array<t>) = Array<Erase(t)>
+Erase(Array<T>) = Array<Erase(T)>
-Erase(G<t>) = Raw(G<T>) // G<t> is a type constructed with argument t mapped onto parameter T
+Erase(G<T>) = Raw(G)
-Erase(A) = A // A is a type constructor without parameters
+Erase(A) = Raw(A) // `A` is a type constructor without parameters
+                  // NOTE: The latter rule needed for proper erasure inside member scope of A
+                  // E.g. if A has property with type `Foo<String>``
+                  // then it becomes `Foo<(raw) Any!>` inside Erase(A)
 ```
 
 ## Overriding