Added additional parameter for default methods

compiler/backend/src/org/jetbrains/kotlin/codegen/ArgumentGenerator.kt

@@ -31,7 +31,7 @@ abstract class ArgumentGenerator {
      *
      * @see kotlin.reflect.jvm.internal.KCallableImpl.callBy
      */
-    open fun generate(valueArgumentsByIndex: List<ResolvedValueArgument>, actualArgs: List<ResolvedValueArgument>): DefaultCallMask {
+    open fun generate(valueArgumentsByIndex: List<ResolvedValueArgument>, actualArgs: List<ResolvedValueArgument>): DefaultCallArgs {
         assert(valueArgumentsByIndex.size == actualArgs.size) {
             "Value arguments collection should have same size, but ${valueArgumentsByIndex.size} != ${actualArgs.size}"
         }
@@ -48,7 +48,7 @@ abstract class ArgumentGenerator {
             }
         }
 
-        val masks = DefaultCallMask(valueArgumentsByIndex.size)
+        val defaultArgs = DefaultCallArgs(valueArgumentsByIndex.size)
 
         for (argumentWithDeclIndex in actualArgsWithDeclIndex) {
             val argument = argumentWithDeclIndex.arg
@@ -59,7 +59,7 @@ abstract class ArgumentGenerator {
                     generateExpression(declIndex, argument)
                 }
                 is DefaultValueArgument -> {
-                    masks.mark(declIndex)
+                    defaultArgs.mark(declIndex)
                     generateDefault(declIndex, argument)
                 }
                 is VarargValueArgument -> {
@@ -73,7 +73,7 @@ abstract class ArgumentGenerator {
 
         reorderArgumentsIfNeeded(actualArgsWithDeclIndex)
 
-        return masks
+        return defaultArgs
     }
 
     protected open fun generateExpression(i: Int, argument: ExpressionValueArgument) {

compiler/backend/src/org/jetbrains/kotlin/codegen/CallBasedArgumentGenerator.java

@@ -51,15 +51,15 @@ public class CallBasedArgumentGenerator extends ArgumentGenerator {
 
     @NotNull
     @Override
-    public DefaultCallMask generate(
+    public DefaultCallArgs generate(
             @NotNull List<? extends ResolvedValueArgument> valueArgumentsByIndex,
             @NotNull List<? extends ResolvedValueArgument> valueArgs
     ) {
         boolean shouldMarkLineNumbers = this.codegen.isShouldMarkLineNumbers();
         this.codegen.setShouldMarkLineNumbers(false);
-        DefaultCallMask masks = super.generate(valueArgumentsByIndex, valueArgs);
+        DefaultCallArgs defaultArgs = super.generate(valueArgumentsByIndex, valueArgs);
         this.codegen.setShouldMarkLineNumbers(shouldMarkLineNumbers);
-        return masks;
+        return defaultArgs;
     }
 
     @Override

compiler/backend/src/org/jetbrains/kotlin/codegen/CallableMethod.kt

@@ -62,7 +62,6 @@ class CallableMethod(
         val method = getAsmMethod()
 
         if ("<init>".equals(method.name)) {
-            v.aconst(null)
             v.visitMethodInsn(INVOKESPECIAL, defaultImplOwner.internalName, "<init>", defaultMethodDesc, false)
         }
         else {

compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultCallArgs.kt

@@ -16,10 +16,11 @@
 
 package org.jetbrains.kotlin.codegen
 
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.org.objectweb.asm.Type
 import java.util.*
 
-class DefaultCallMask(val size: Int) {
+class DefaultCallArgs(val size: Int) {
 
     val bits: BitSet = BitSet(size)
 
@@ -50,10 +51,15 @@ class DefaultCallMask(val size: Int) {
         return masks
     }
 
-    fun generateOnStackIfNeeded(callGenerator: CallGenerator): Boolean {
+    fun generateOnStackIfNeeded(callGenerator: CallGenerator, isConstructor: Boolean): Boolean {
         val toInts = toInts()
-        for (mask in toInts) {
-            callGenerator.putValueIfNeeded(Type.INT_TYPE, StackValue.constant(mask, Type.INT_TYPE))
+        if (!toInts.isEmpty()) {
+            for (mask in toInts) {
+                callGenerator.putValueIfNeeded(Type.INT_TYPE, StackValue.constant(mask, Type.INT_TYPE))
+            }
+
+            val parameterType = if (isConstructor) AsmTypes.DEFAULT_CONSTRUCTOR_MARKER else AsmTypes.OBJECT_TYPE
+            callGenerator.putValueIfNeeded(parameterType, StackValue.constant(null, parameterType))
         }
         return toInts.isNotEmpty();
     }

compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt

@@ -184,14 +184,14 @@ class DefaultParameterValueSubstitutor(val state: GenerationState) {
             }
         }
         masks.add(mask)
+
         for (m in masks) {
             v.iconst(m)
         }
 
-        // constructors with default arguments has last synthetic argument of specific type
-        if (functionDescriptor is ConstructorDescriptor) {
-            v.aconst(null)
-        }
+        // for default constructors: just marks default constructor (see DEFAULT_CONSTRUCTOR_MARKER)
+        // for default methods: contains MethodHandle for super calls ('null' cause not super call)
+        v.aconst(null)
 
         val defaultMethod = typeMapper.mapDefaultMethod(delegateFunctionDescriptor, contextKind)
         if (functionDescriptor is ConstructorDescriptor) {

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -2378,7 +2378,8 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             @NotNull CallGenerator callGenerator,
             @NotNull ArgumentGenerator argumentGenerator
     ) {
-        if (!(resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor)) { // otherwise already
+        boolean isConstructor = resolvedCall.getResultingDescriptor() instanceof ConstructorDescriptor;
+        if (!isConstructor) { // otherwise already
             receiver = StackValue.receiver(resolvedCall, receiver, this, callableMethod);
             receiver.put(receiver.type, v);
             callableMethod.afterReceiverGeneration(v);
@@ -2389,7 +2390,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         List<ResolvedValueArgument> valueArguments = resolvedCall.getValueArgumentsByIndex();
         assert valueArguments != null : "Failed to arrange value arguments by index: " + resolvedCall.getResultingDescriptor();
 
-        DefaultCallMask masks =
+        DefaultCallArgs defaultArgs =
                 argumentGenerator.generate(valueArguments, new ArrayList<ResolvedValueArgument>(resolvedCall.getValueArguments().values()));
 
         if (tailRecursionCodegen.isTailRecursion(resolvedCall)) {
@@ -2397,7 +2398,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
             return;
         }
 
-        boolean defaultMaskWasGenerated = masks.generateOnStackIfNeeded(callGenerator);
+        boolean defaultMaskWasGenerated = defaultArgs.generateOnStackIfNeeded(callGenerator, isConstructor);
 
         // Extra constructor marker argument
         if (callableMethod instanceof CallableMethod) {

compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java

@@ -774,7 +774,7 @@ public abstract class StackValue {
         private final StackValue receiver;
         private final ResolvedCall<FunctionDescriptor> resolvedGetCall;
         private final ResolvedCall<FunctionDescriptor> resolvedSetCall;
-        private DefaultCallMask mask;
+        private DefaultCallArgs defaultArgs;
         private CallGenerator callGenerator;
         boolean isComplexOperationWithDup;
 
@@ -807,7 +807,7 @@ public abstract class StackValue {
             newReceiver.put(newReceiver.type, v);
             callGenerator.putHiddenParams();
 
-            mask = generator.generate(valueArguments, valueArguments);
+            defaultArgs = generator.generate(valueArguments, valueArguments);
         }
 
         private ArgumentGenerator createArgumentGenerator() {
@@ -955,8 +955,8 @@ public abstract class StackValue {
         }
 
         private boolean genDefaultMaskIfPresent(CallGenerator callGenerator) {
-            DefaultCallMask mask = ((CollectionElementReceiver) receiver).mask;
-            return mask.generateOnStackIfNeeded(callGenerator);
+            DefaultCallArgs defaultArgs = ((CollectionElementReceiver) receiver).defaultArgs;
+            return defaultArgs.generateOnStackIfNeeded(callGenerator, true);
         }
 
         private CallGenerator getCallGenerator() {

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

@@ -88,6 +88,7 @@ import static org.jetbrains.kotlin.resolve.BindingContextUtils.getDelegationCons
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.isVarCapturedInClosure;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.DEFAULT_CONSTRUCTOR_MARKER;
+import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
@@ -1104,9 +1105,7 @@ public class JetTypeMapper {
         }
         int maskArgumentsCount = (argumentsCount + Integer.SIZE - 1) / Integer.SIZE;
         String additionalArgs = StringUtil.repeat(Type.INT_TYPE.getDescriptor(), maskArgumentsCount);
-        if (isConstructor(method)) {
-            additionalArgs += DEFAULT_CONSTRUCTOR_MARKER.getDescriptor();
-        }
+        additionalArgs += (isConstructor(method) ? DEFAULT_CONSTRUCTOR_MARKER : OBJECT_TYPE).getDescriptor();
         String result = descriptor.replace(")", additionalArgs + ")");
         if (dispatchReceiverDescriptor != null && !isConstructor(method)) {
             return result.replace("(", "(" + dispatchReceiverDescriptor);