Fix logic of forcing method return type to be wrapped

Return type must be wrapped if any super-method in the hierarchy, not just the
direct super-method, returns a reference type (as opposed to a primitive type)

Actually there was a test reflecting this, but it wasn't running because of an
unfixed diagnostic error

compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java

@@ -24,9 +24,6 @@ import org.jetbrains.jet.codegen.binding.CalculatedClosure;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.signature.BothSignatureWriter;
-import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodParameterKind;
-import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodParameterSignature;
-import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
 import org.jetbrains.jet.config.IncrementalCompilation;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedCallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -36,10 +33,14 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassStaticsPackageFragmentDescriptor;
+import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodParameterKind;
+import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodParameterSignature;
+import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
 import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.types.*;
@@ -605,7 +606,7 @@ public class JetTypeMapper {
         //noinspection ConstantConditions
         if (!KotlinBuiltIns.getInstance().isPrimitiveType(descriptor.getReturnType())) return false;
 
-        for (FunctionDescriptor overridden : descriptor.getOverriddenDescriptors()) {
+        for (FunctionDescriptor overridden : OverrideResolver.getAllOverriddenDescriptors(descriptor)) {
             //noinspection ConstantConditions
             if (!KotlinBuiltIns.getInstance().isPrimitiveType(overridden.getOriginal().getReturnType())) return true;
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java

@@ -264,22 +264,25 @@ public class OverrideResolver {
 
     public static <D extends CallableDescriptor> boolean overrides(@NotNull D f, @NotNull D g) {
         CallableDescriptor originalG = g.getOriginal();
-        for (CallableDescriptor overriddenFunction : getAllOverriddenDescriptors(f)) {
+        for (D overriddenFunction : getAllOverriddenDescriptors(f)) {
             if (originalG.equals(overriddenFunction.getOriginal())) return true;
         }
         return false;
     }
 
     @NotNull
-    public static Set<CallableDescriptor> getAllOverriddenDescriptors(@NotNull CallableDescriptor f) {
+    @SuppressWarnings("unchecked")
-        Set<CallableDescriptor> result = new LinkedHashSet<CallableDescriptor>();
+    public static <D extends CallableDescriptor> Set<D> getAllOverriddenDescriptors(@NotNull D f) {
-        collectAllOverriddenDescriptors(f.getOriginal(), result);
+        Set<D> result = new LinkedHashSet<D>();
+        collectAllOverriddenDescriptors((D) f.getOriginal(), result);
         return result;
     }
 
-    private static void collectAllOverriddenDescriptors(@NotNull CallableDescriptor current, @NotNull Set<CallableDescriptor> result) {
+    private static <D extends CallableDescriptor> void collectAllOverriddenDescriptors(@NotNull D current, @NotNull Set<D> result) {
         if (result.contains(current)) return;
-        for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) {
+        for (CallableDescriptor callableDescriptor : current.getOriginal().getOverriddenDescriptors()) {
+            @SuppressWarnings("unchecked")
+            D descriptor = (D) callableDescriptor;
             collectAllOverriddenDescriptors(descriptor, result);
             result.add(descriptor);
         }

compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ManyClassesHierarchy.kt

@@ -4,7 +4,7 @@ trait A<T> {
     fun foo(): T
 }
 
-trait B : A
+trait B : A<Int>
 
 abstract class C : B