From 2b5bc6b63dda0c71f57d78d52cf94981f8ef5531 Mon Sep 17 00:00:00 2001
From: Alexander Udalov <Alexander.Udalov@jetbrains.com>
Date: Thu, 29 May 2014 18:16:09 +0400
Subject: [PATCH] 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
---
 .../jet/codegen/state/JetTypeMapper.java          |  9 +++++----
 .../jet/lang/resolve/OverrideResolver.java        | 15 +++++++++------
 .../primitiveOverride/ManyClassesHierarchy.kt     |  2 +-
 3 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
index 9b73d3e39e9..8a0111111d0 100644
--- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
+++ b/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;
         }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
index 4dfc6bc8d36..b511a33ea7c 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
+++ b/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) {
-        Set<CallableDescriptor> result = new LinkedHashSet<CallableDescriptor>();
-        collectAllOverriddenDescriptors(f.getOriginal(), result);
+    @SuppressWarnings("unchecked")
+    public static <D extends CallableDescriptor> Set<D> getAllOverriddenDescriptors(@NotNull D f) {
+        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);
         }
diff --git a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ManyClassesHierarchy.kt b/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ManyClassesHierarchy.kt
index 5fc8d51b042..825917181d6 100644
--- a/compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride/ManyClassesHierarchy.kt
+++ b/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