Fixed problem with overriding method with non-trivial raw type (when erased type parameter has upper bound)

Also added cases for the code which was changed.

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

@@ -0,0 +1,15 @@
+//FILE: Foo.java
+public class Foo<T extends CharSequence> {
+}
+
+//FILE: Bar.java
+public interface Bar {
+    void f(Foo f);
+}
+
+//FILE: a.kt
+class BarImpl: Bar {
+    override fun f(f: Foo<out CharSequence?>?) {
+        throw UnsupportedOperationException()
+    }
+}

compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.java

@@ -0,0 +1,11 @@
+package test;
+
+public interface RawTypeWithUpperBound {
+
+    public interface Foo<T extends CharSequence> {
+    }
+
+    interface Bar {
+        void f(Foo f);
+    }
+}

compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.txt

@@ -0,0 +1,15 @@
+package test
+
+public trait RawTypeWithUpperBound : java.lang.Object {
+    
+    public trait Bar : java.lang.Object {
+        public abstract fun f(/*0*/ p0: test.RawTypeWithUpperBound.Foo<out jet.CharSequence?>?): jet.Unit
+    }
+    
+    public trait Foo</*0*/ T : jet.CharSequence?> : java.lang.Object {
+    }
+}
+
+package test.RawTypeWithUpperBound {
+    public /*synthesized*/ fun Bar(/*0*/ function: (test.RawTypeWithUpperBound.Foo<out jet.CharSequence?>?) -> jet.Unit): test.RawTypeWithUpperBound.Bar
+}

compiler/testData/loadJava/compiledJava/RawUpperBound.java

@@ -0,0 +1,4 @@
+package test;
+
+public interface RawUpperBound<T extends RawUpperBound> {
+}

compiler/testData/loadJava/compiledJava/RawUpperBound.txt

@@ -0,0 +1,4 @@
+package test
+
+public trait RawUpperBound</*0*/ T : test.RawUpperBound<out jet.Any?>?> : java.lang.Object {
+}

compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.java

@@ -0,0 +1,4 @@
+package test;
+
+public interface RecursiveRawUpperBound<T extends RecursiveRawUpperBound> {
+}

compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.txt

@@ -0,0 +1,4 @@
+package test
+
+public trait RecursiveRawUpperBound</*0*/ T : test.RecursiveRawUpperBound<out jet.Any?>?> : java.lang.Object {
+}

compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.java

@@ -0,0 +1,4 @@
+package test;
+
+public interface RecursiveWildcardUpperBound<T extends RecursiveWildcardUpperBound> {
+}

compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.txt

@@ -0,0 +1,4 @@
+package test
+
+public trait RecursiveWildcardUpperBound</*0*/ T : test.RecursiveWildcardUpperBound<out jet.Any?>?> : java.lang.Object {
+}

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -4558,6 +4558,11 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
                 doTest("compiler/testData/diagnostics/tests/j+k/mutableIterator.kt");
             }
             
+            @TestMetadata("overrideRawType.kt")
+            public void testOverrideRawType() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/j+k/overrideRawType.kt");
+            }
+            
             @TestMetadata("OverrideVararg.kt")
             public void testOverrideVararg() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/j+k/OverrideVararg.kt");

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java

@@ -59,6 +59,26 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
             doTestCompiledJava("compiler/testData/loadJava/compiledJava/PackageLocalVisibility.java");
         }
         
+        @TestMetadata("RawTypeWithUpperBound.java")
+        public void testRawTypeWithUpperBound() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/RawTypeWithUpperBound.java");
+        }
+        
+        @TestMetadata("RawUpperBound.java")
+        public void testRawUpperBound() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/RawUpperBound.java");
+        }
+        
+        @TestMetadata("RecursiveRawUpperBound.java")
+        public void testRecursiveRawUpperBound() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/RecursiveRawUpperBound.java");
+        }
+        
+        @TestMetadata("RecursiveWildcardUpperBound.java")
+        public void testRecursiveWildcardUpperBound() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/RecursiveWildcardUpperBound.java");
+        }
+        
         @TestMetadata("SubclassFromNested.java")
         public void testSubclassFromNested() throws Exception {
             doTestCompiledJava("compiler/testData/loadJava/compiledJava/SubclassFromNested.java");