Assertions when approximating platform types in delegation by expression

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -25,7 +25,6 @@ import com.intellij.util.containers.ContainerUtil;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.codegen.binding.CalculatedClosure;
 import org.jetbrains.jet.codegen.binding.CodegenBinding;
 import org.jetbrains.jet.codegen.bridges.Bridge;
 import org.jetbrains.jet.codegen.bridges.BridgesPackage;
@@ -51,6 +50,8 @@ 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.name.FqName;
+import org.jetbrains.jet.lang.types.Approximation;
+import org.jetbrains.jet.lang.types.TypesPackage;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
 import org.jetbrains.org.objectweb.asm.Label;
@@ -799,21 +800,20 @@ public class FunctionCodegen extends ParentCodegenAware {
     }
 
     public void genDelegate(FunctionDescriptor functionDescriptor, FunctionDescriptor overriddenDescriptor, StackValue field) {
-        genDelegate(functionDescriptor, (ClassDescriptor) overriddenDescriptor.getContainingDeclaration(), field,
-                    typeMapper.mapSignature(functionDescriptor),
-                    typeMapper.mapSignature(overriddenDescriptor.getOriginal())
+        genDelegate(functionDescriptor, overriddenDescriptor.getOriginal(), (ClassDescriptor) overriddenDescriptor.getContainingDeclaration(), field
         );
     }
 
     public void genDelegate(
-            FunctionDescriptor functionDescriptor,
+            final FunctionDescriptor delegateFunction,
+            final FunctionDescriptor delegatedTo,
             final ClassDescriptor toClass,
-            final StackValue field,
-            final JvmMethodSignature jvmDelegateMethodSignature,
-            final JvmMethodSignature jvmDelegatingMethodSignature
+            final StackValue field
     ) {
+        final JvmMethodSignature jvmDelegateMethodSignature = typeMapper.mapSignature(delegateFunction);
+        final JvmMethodSignature jvmDelegateToMethodSignature = typeMapper.mapSignature(delegatedTo);
         generateMethod(
-                OtherOrigin(functionDescriptor), jvmDelegateMethodSignature, functionDescriptor,
+                OtherOrigin(delegateFunction), jvmDelegateMethodSignature, delegateFunction,
                 new FunctionGenerationStrategy() {
                     @Override
                     public void generateBody(
@@ -823,11 +823,11 @@ public class FunctionCodegen extends ParentCodegenAware {
                             @NotNull MethodContext context,
                             @NotNull MemberCodegen<?> parentCodegen
                     ) {
-                        Method overriddenMethod = jvmDelegatingMethodSignature.getAsmMethod();
+                        Method delegateToMethod = jvmDelegateToMethodSignature.getAsmMethod();
                         Method delegateMethod = jvmDelegateMethodSignature.getAsmMethod();
 
                         Type[] argTypes = delegateMethod.getArgumentTypes();
-                        Type[] originalArgTypes = overriddenMethod.getArgumentTypes();
+                        Type[] originalArgTypes = delegateToMethod.getArgumentTypes();
 
                         InstructionAdapter iv = new InstructionAdapter(mv);
                         iv.load(0, OBJECT_TYPE);
@@ -840,13 +840,22 @@ public class FunctionCodegen extends ParentCodegenAware {
 
                         String internalName = typeMapper.mapType(toClass).getInternalName();
                         if (toClass.getKind() == ClassKind.TRAIT) {
-                            iv.invokeinterface(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor());
+                            iv.invokeinterface(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor());
                         }
                         else {
-                            iv.invokevirtual(internalName, overriddenMethod.getName(), overriddenMethod.getDescriptor());
+                            iv.invokevirtual(internalName, delegateToMethod.getName(), delegateToMethod.getDescriptor());
                         }
 
-                        StackValue.onStack(overriddenMethod.getReturnType()).put(delegateMethod.getReturnType(), iv);
+                        StackValue stackValue = AsmUtil.genNotNullAssertions(
+                                state,
+                                StackValue.onStack(delegateToMethod.getReturnType()),
+                                TypesPackage.getApproximationTo(
+                                        delegatedTo.getReturnType(),
+                                        delegateFunction.getReturnType(),
+                                        new Approximation.DataFlowExtras.OnlyMessage(delegatedTo.getName() + "(...)"))
+                        );
+
+                        stackValue.put(delegateMethod.getReturnType(), iv);
 
                         iv.areturn(delegateMethod.getReturnType());
                     }

compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java

@@ -24,6 +24,7 @@ import kotlin.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.backend.common.CodegenUtil;
+import org.jetbrains.jet.backend.common.CodegenUtilKt;
 import org.jetbrains.jet.backend.common.DataClassMethodGenerator;
 import org.jetbrains.jet.codegen.binding.MutableClosure;
 import org.jetbrains.jet.codegen.context.*;
@@ -1286,13 +1287,15 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 JetExpression expression = ((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
                 PropertyDescriptor propertyDescriptor = CodegenUtil.getDelegatePropertyIfAny(expression, descriptor, bindingContext);
 
-                ClassDescriptor superClassDescriptor = getSuperClass(specifier);
 
                 if (CodegenUtil.isFinalPropertyWithBackingField(propertyDescriptor, bindingContext)) {
                     result.addField((JetDelegatorByExpressionSpecifier) specifier, propertyDescriptor);
                 }
                 else {
-                    result.addField((JetDelegatorByExpressionSpecifier) specifier, typeMapper.mapType(superClassDescriptor), "$delegate_" + n);
+                    JetType expressionType = state.getBindingContext().get(BindingContext.EXPRESSION_TYPE, expression);
+                    Type asmType =
+                            expressionType != null ? typeMapper.mapType(expressionType) : typeMapper.mapType(getSuperClass(specifier));
+                    result.addField((JetDelegatorByExpressionSpecifier) specifier, asmType, "$delegate_" + n);
                 }
                 n++;
             }
@@ -1648,7 +1651,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             if (specifier instanceof JetDelegatorByExpressionSpecifier) {
                 DelegationFieldsInfo.Field field = delegationFieldsInfo.getInfo((JetDelegatorByExpressionSpecifier) specifier);
                 generateDelegateField(field);
-                generateDelegates(getSuperClass(specifier), field);
+                JetExpression delegateExpression = ((JetDelegatorByExpressionSpecifier) specifier).getDelegateExpression();
+                JetType delegateExpressionType = state.getBindingContext().get(BindingContext.EXPRESSION_TYPE, delegateExpression);
+                generateDelegates(getSuperClass(specifier), delegateExpressionType, field);
             }
         }
     }
@@ -1660,17 +1665,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                    fieldInfo.name, fieldInfo.type.getDescriptor(), /*TODO*/null, null);
     }
 
-    protected void generateDelegates(ClassDescriptor toClass, DelegationFieldsInfo.Field field) {
-        for (Map.Entry<CallableMemberDescriptor, CallableMemberDescriptor> entry : CodegenUtil.getDelegates(descriptor, toClass).entrySet()) {
+    protected void generateDelegates(ClassDescriptor toTrait, JetType delegateExpressionType, DelegationFieldsInfo.Field field) {
+        for (Map.Entry<CallableMemberDescriptor, CallableDescriptor> entry : CodegenUtilKt.getDelegates(descriptor, toTrait, delegateExpressionType).entrySet()) {
             CallableMemberDescriptor callableMemberDescriptor = entry.getKey();
-            CallableMemberDescriptor overriddenDescriptor = entry.getValue();
+            CallableDescriptor delegateTo = entry.getValue();
             if (callableMemberDescriptor instanceof PropertyDescriptor) {
                 propertyCodegen
-                        .genDelegate((PropertyDescriptor) callableMemberDescriptor, (PropertyDescriptor) overriddenDescriptor, field.getStackValue());
+                        .genDelegate((PropertyDescriptor) callableMemberDescriptor, (PropertyDescriptor) delegateTo, field.getStackValue());
             }
             else if (callableMemberDescriptor instanceof FunctionDescriptor) {
                 functionCodegen
-                        .genDelegate((FunctionDescriptor) callableMemberDescriptor, (FunctionDescriptor) overriddenDescriptor, field.getStackValue());
+                        .genDelegate((FunctionDescriptor) callableMemberDescriptor, (FunctionDescriptor) delegateTo, field.getStackValue());
             }
         }
     }

compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java

@@ -484,21 +484,19 @@ public class PropertyCodegen {
         return JvmAbi.SETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName.asString());
     }
 
-    public void genDelegate(@NotNull PropertyDescriptor delegate, @NotNull PropertyDescriptor overridden, @NotNull StackValue field) {
-        ClassDescriptor toClass = (ClassDescriptor) overridden.getContainingDeclaration();
+    public void genDelegate(@NotNull PropertyDescriptor delegate, @NotNull PropertyDescriptor delegateTo, @NotNull StackValue field) {
+        ClassDescriptor toClass = (ClassDescriptor) delegateTo.getContainingDeclaration();
 
         PropertyGetterDescriptor getter = delegate.getGetter();
         if (getter != null) {
             //noinspection ConstantConditions
-            functionCodegen.genDelegate(getter, toClass, field,
-                                        typeMapper.mapSignature(getter), typeMapper.mapSignature(overridden.getGetter().getOriginal()));
+            functionCodegen.genDelegate(getter, delegateTo.getGetter().getOriginal(), toClass, field);
         }
 
         PropertySetterDescriptor setter = delegate.getSetter();
         if (setter != null) {
             //noinspection ConstantConditions
-            functionCodegen.genDelegate(setter, toClass, field,
-                                        typeMapper.mapSignature(setter), typeMapper.mapSignature(overridden.getSetter().getOriginal()));
+            functionCodegen.genDelegate(setter, delegateTo.getSetter().getOriginal(), toClass, field);
         }
     }
 }