Fix JavaClassifierType.getTypeArguments impls

Make them return arguments both for current classifier and for the outer one

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaClassifierTypeImpl.java

@@ -17,14 +17,13 @@
 package org.jetbrains.kotlin.load.java.structure.impl;
 
 import com.intellij.psi.*;
+import com.intellij.psi.util.PsiUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.load.java.structure.*;
 
 import java.util.*;
 
-import static org.jetbrains.kotlin.load.java.structure.impl.JavaElementCollectionFromPsiArrayUtil.types;
-
 public class JavaClassifierTypeImpl extends JavaTypeImpl<PsiClassType> implements JavaClassifierType {
     private static class ResolutionResult {
         private final JavaClassifier classifier;
@@ -110,6 +109,33 @@ public class JavaClassifierTypeImpl extends JavaTypeImpl<PsiClassType> implement
     @Override
     @NotNull
     public List<JavaType> getTypeArguments() {
-        return types(getPsi().getParameters());
+        JavaClassifier classifier = getClassifier();
+
+        // parameters including ones from outer class
+        Iterable<PsiTypeParameter> parameters = classifier instanceof JavaClassImpl
+                     ? getReversedTypeParameters((JavaClassImpl) classifier)
+                     : Collections.<PsiTypeParameter>emptyList();
+
+        JavaTypeSubstitutor substitutor = getSubstitutor();
+
+        List<JavaType> result = new ArrayList<JavaType>();
+        for (PsiTypeParameter typeParameter : parameters) {
+            result.add(substitutor.substitute(new JavaTypeParameterImpl(typeParameter)));
+        }
+
+        return result;
+    }
+
+    private static Collection<PsiTypeParameter> getReversedTypeParameters(@NotNull JavaClassImpl classifier) {
+        Iterable<PsiTypeParameter> parameters = PsiUtil.typeParametersIterable(classifier.getPsi());
+        List<PsiTypeParameter> result = new ArrayList<PsiTypeParameter>();
+
+        for (PsiTypeParameter parameter : parameters) {
+            result.add(parameter);
+        }
+
+        Collections.reverse(result);
+
+        return result;
     }
 }

compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.runtime.txt

@@ -0,0 +1,14 @@
+package test
+
+public open class InnerClassesInGeneric</*0*/ P : kotlin.Any!, /*1*/ Q : kotlin.Any!> {
+    public constructor InnerClassesInGeneric</*0*/ P : kotlin.Any!, /*1*/ Q : kotlin.Any!>()
+
+    public open inner class Inner {
+        public constructor Inner()
+    }
+
+    public open inner class Inner2 : test.InnerClassesInGeneric<kotlin.Any!, kotlin.Any!>.Inner {
+        public constructor Inner2()
+        public open operator fun iterator(): kotlin.(Mutable)Iterator<P!>!
+    }
+}

compiler/testData/loadJava/compiledJava/InnerClassesInGeneric.txt

@@ -7,7 +7,7 @@ public open class InnerClassesInGeneric</*0*/ P : kotlin.Any!, /*1*/ Q : kotlin.
         public constructor Inner()
     }
 
-    public open inner class Inner2 : test.InnerClassesInGeneric.Inner {
+    public open inner class Inner2 : test.InnerClassesInGeneric<P!, Q!>.Inner {
         public constructor Inner2()
         public open operator fun iterator(): kotlin.(Mutable)Iterator<P!>!
     }

compiler/testData/loadJava/compiledJava/InnerOfGeneric.runtime.txt

@@ -0,0 +1,28 @@
+package test
+
+public open class InnerOfGeneric {
+    public constructor InnerOfGeneric()
+
+    public abstract inner class A</*0*/ K : kotlin.Any!> {
+        public constructor A</*0*/ K : kotlin.Any!>()
+
+        public abstract inner class Inner : test.InnerOfGeneric.S<K!> {
+            public constructor Inner()
+            public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.(Mutable)Iterator<K!>!
+        }
+    }
+
+    public open inner class B</*0*/ L : kotlin.Any!> : test.InnerOfGeneric.A<L!> {
+        public constructor B</*0*/ L : kotlin.Any!>()
+
+        public open inner class SubInner : test.InnerOfGeneric.A<kotlin.Any!>.Inner {
+            public constructor SubInner()
+            public open override /*1*/ fun iterator(): kotlin.(Mutable)Iterator<L!>!
+        }
+    }
+
+    public open inner class S</*0*/ E : kotlin.Any!> {
+        public constructor S</*0*/ E : kotlin.Any!>()
+        public open operator fun iterator(): kotlin.(Mutable)Iterator<E!>!
+    }
+}

compiler/testData/loadJava/compiledJava/InnerOfGeneric.txt

@@ -15,7 +15,7 @@ public open class InnerOfGeneric {
     public open inner class B</*0*/ L : kotlin.Any!> : test.InnerOfGeneric.A<L!> {
         public constructor B</*0*/ L : kotlin.Any!>()
 
-        public open inner class SubInner : test.InnerOfGeneric.A.Inner {
+        public open inner class SubInner : test.InnerOfGeneric.A<L!>.Inner {
             public constructor SubInner()
             public open override /*1*/ fun iterator(): kotlin.(Mutable)Iterator<L!>!
         }

compiler/testData/loadJava/compiledJava/signaturePropagation/ReturnInnerSubclassOfSupersInner.runtime.txt

@@ -0,0 +1,22 @@
+package test
+
+public interface ReturnInnerSubclassOfSupersInner {
+
+    public open class Sub</*0*/ B : kotlin.Any!> : test.ReturnInnerSubclassOfSupersInner.Super<B!> {
+        public constructor Sub</*0*/ B : kotlin.Any!>()
+
+        public/*package*/ open inner class Inner : test.ReturnInnerSubclassOfSupersInner.Super<kotlin.Any!>.Inner {
+            public/*package*/ constructor Inner()
+            public/*package*/ open override /*1*/ fun get(): test.ReturnInnerSubclassOfSupersInner.Sub<B!>!
+        }
+    }
+
+    public open class Super</*0*/ A : kotlin.Any!> {
+        public constructor Super</*0*/ A : kotlin.Any!>()
+
+        public/*package*/ open inner class Inner {
+            public/*package*/ constructor Inner()
+            public/*package*/ open fun get(): test.ReturnInnerSubclassOfSupersInner.Super<A!>!
+        }
+    }
+}

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

@@ -5,7 +5,7 @@ public interface ReturnInnerSubclassOfSupersInner {
     public open class Sub</*0*/ B : kotlin.Any!> : test.ReturnInnerSubclassOfSupersInner.Super<B!> {
         public constructor Sub</*0*/ B : kotlin.Any!>()
 
-        public/*package*/ open inner class Inner : test.ReturnInnerSubclassOfSupersInner.Super.Inner {
+        public/*package*/ open inner class Inner : test.ReturnInnerSubclassOfSupersInner.Super<B!>.Inner {
             public/*package*/ constructor Inner()
             public/*package*/ open override /*1*/ fun get(): test.ReturnInnerSubclassOfSupersInner.Sub<B!>!
         }

compiler/testData/loadJava/sourceJava/ReturnInnerSubclassOfSupersInner.txt

@@ -5,7 +5,7 @@ public interface ReturnInnerSubclassOfSupersInner {
     public open class Sub</*0*/ B : kotlin.Any!> : test.ReturnInnerSubclassOfSupersInner.Super<B!> {
         public constructor Sub</*0*/ B : kotlin.Any!>()
 
-        public/*package*/ open inner class Inner : test.ReturnInnerSubclassOfSupersInner.Super.Inner {
+        public/*package*/ open inner class Inner : test.ReturnInnerSubclassOfSupersInner.Super<B!>.Inner {
             public/*package*/ constructor Inner()
             public/*package*/ open override /*1*/ fun get(): test.ReturnInnerSubclassOfSupersInner.Sub<B!>!
         }

compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.java

@@ -8,6 +8,7 @@ public interface WrongNumberOfGenericParameters {
     Zero<String> z();
 
     One o0();
+    // Our Java resolve supposes that return type has exactly one argument
     One<String, String> o2();
 
     // This does not produce the expected result, because IDEA thinks Two<X> is a raw type

compiler/testData/loadJava/sourceJava/WrongNumberOfGenericParameters.txt

@@ -2,7 +2,7 @@ package test
 
 public interface WrongNumberOfGenericParameters {
     public abstract fun o0(): test.WrongNumberOfGenericParameters.One<(raw) kotlin.Any!>!
-    public abstract fun o2(): test.WrongNumberOfGenericParameters.One<[ERROR : T]>!
+    public abstract fun o2(): test.WrongNumberOfGenericParameters.One<kotlin.String!>!
     public abstract fun t1(): test.WrongNumberOfGenericParameters.Two<(raw) kotlin.Any!, (raw) kotlin.Any!>!
     public abstract fun z(): test.WrongNumberOfGenericParameters.Zero!
 

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt

@@ -45,7 +45,9 @@ public class ReflectJavaClassifierType(public override val type: Type) : Reflect
     override fun isRaw(): Boolean = with(type) { this is Class<*> && getTypeParameters().isNotEmpty() }
 
     override fun getTypeArguments(): List<JavaType> {
-        return (type as? ParameterizedType)?.getActualTypeArguments()?.map { ReflectJavaType.create(it) } ?: listOf()
+        return sequence({type as? ParameterizedType}, { it.ownerType as? ParameterizedType }).flatMap {
+            it.actualTypeArguments.asSequence().map { ReflectJavaType.create(it) }
+        }.toList()
     }
 
     override fun getAnnotations(): Collection<JavaAnnotation> {