Remove useless parameter of FunctionCodegen.generateDefault

JvmMethodSignature can now be perfectly obtained by JetTypeMapper.mapSignature

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

@@ -191,12 +191,9 @@ public class ClosureCodegen extends MemberCodegen<JetElement> {
 
         genClosureFields(closure, v, typeMapper);
 
-        functionCodegen.generateDefaultIfNeeded(context.intoFunction(funDescriptor),
+        functionCodegen.generateDefaultIfNeeded(
-                                                typeMapper.mapSignature(funDescriptor),
+                context.intoFunction(funDescriptor), funDescriptor, context.getContextKind(), DefaultParameterValueLoader.DEFAULT, null
-                                                funDescriptor,
+        );
-                                                context.getContextKind(),
-                                                DefaultParameterValueLoader.DEFAULT,
-                                                null);
     }
 
     @Override

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

@@ -106,15 +106,12 @@ public class FunctionCodegen {
         assert functionDescriptor != null : "No descriptor for function " + function.getText() + "\n" +
                                             "in " + function.getContainingFile().getVirtualFile();
 
-        OwnerKind kind = owner.getContextKind();
+        if (owner.getContextKind() != OwnerKind.TRAIT_IMPL || function.hasBody()) {
-        JvmMethodSignature method = typeMapper.mapSignature(functionDescriptor, kind);
-
-        if (kind != OwnerKind.TRAIT_IMPL || function.hasBody()) {
             generateMethod(OtherOrigin(function, functionDescriptor), functionDescriptor,
                            new FunctionGenerationStrategy.FunctionDefault(state, functionDescriptor, function));
         }
 
-        generateDefaultIfNeeded(owner.intoFunction(functionDescriptor), method, functionDescriptor, kind,
+        generateDefaultIfNeeded(owner.intoFunction(functionDescriptor), functionDescriptor, owner.getContextKind(),
                                 DefaultParameterValueLoader.DEFAULT, function);
     }
 
@@ -593,7 +590,6 @@ public class FunctionCodegen {
 
     void generateDefaultIfNeeded(
             @NotNull MethodContext owner,
-            @NotNull JvmMethodSignature signature,
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull OwnerKind kind,
             @NotNull DefaultParameterValueLoader loadStrategy,
@@ -611,18 +607,19 @@ public class FunctionCodegen {
             return;
         }
 
-        Method jvmSignature = signature.getAsmMethod();
+        int flags = getVisibilityAccessFlag(functionDescriptor) |
-
+                    getDeprecatedAccessFlag(functionDescriptor) |
-        int flags = getVisibilityAccessFlag(functionDescriptor) | getDeprecatedAccessFlag(functionDescriptor);
+                    (functionDescriptor instanceof ConstructorDescriptor ? 0 : ACC_STATIC);
-
-        boolean isConstructor = "<init>".equals(jvmSignature.getName());
 
         Method defaultMethod = typeMapper.mapDefaultMethod(functionDescriptor, kind, owner);
 
-        MethodVisitor mv = v.newMethod(Synthetic(function, functionDescriptor), flags | (isConstructor ? 0 : ACC_STATIC),
+        MethodVisitor mv = v.newMethod(
-                                       defaultMethod.getName(),
+                Synthetic(function, functionDescriptor),
-                                       defaultMethod.getDescriptor(), null,
+                flags,
-                                       getThrownExceptions(functionDescriptor, typeMapper));
+                defaultMethod.getName(),
+                defaultMethod.getDescriptor(), null,
+                getThrownExceptions(functionDescriptor, typeMapper)
+        );
 
         if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
             if (this.owner instanceof PackageFacadeContext) {
@@ -631,36 +628,25 @@ public class FunctionCodegen {
                 endVisit(mv, "default method delegation", callableDescriptorToDeclaration(functionDescriptor));
             }
             else {
-                generateDefaultImpl(owner, signature, functionDescriptor, isStaticMethod(kind, functionDescriptor), mv, loadStrategy, function);
+                mv.visitCode();
+                generateDefaultImplBody(owner, functionDescriptor, mv, loadStrategy, function, memberCodegen);
+                endVisit(mv, "default method", callableDescriptorToDeclaration(functionDescriptor));
             }
         }
     }
 
-    private void generateDefaultImpl(
-            @NotNull MethodContext methodContext,
-            @NotNull JvmMethodSignature signature,
-            @NotNull FunctionDescriptor functionDescriptor,
-            boolean isStatic,
-            @NotNull MethodVisitor mv,
-            @NotNull DefaultParameterValueLoader loadStrategy,
-            @Nullable JetNamedFunction function
-    ) {
-        mv.visitCode();
-        generateDefaultImplBody(methodContext, signature, functionDescriptor, isStatic, mv, loadStrategy, function, memberCodegen, state);
-        endVisit(mv, "default method", callableDescriptorToDeclaration(functionDescriptor));
-    }
-
     public static void generateDefaultImplBody(
             @NotNull MethodContext methodContext,
-            @NotNull JvmMethodSignature signature,
             @NotNull FunctionDescriptor functionDescriptor,
-            boolean isStatic,
             @NotNull MethodVisitor mv,
             @NotNull DefaultParameterValueLoader loadStrategy,
             @Nullable JetNamedFunction function,
-            @NotNull MemberCodegen<?> parentCodegen,
+            @NotNull MemberCodegen<?> parentCodegen
-            @NotNull GenerationState state
     ) {
+        GenerationState state = parentCodegen.state;
+        JvmMethodSignature signature = state.getTypeMapper().mapSignature(functionDescriptor, methodContext.getContextKind());
+
+        boolean isStatic = isStaticMethod(methodContext.getContextKind(), functionDescriptor);
         FrameMap frameMap = createFrameMap(state, functionDescriptor, signature, isStatic);
 
         ExpressionCodegen codegen = new ExpressionCodegen(mv, frameMap, signature.getReturnType(), methodContext, state, parentCodegen);

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

@@ -753,7 +753,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             });
 
             functionCodegen.generateDefaultIfNeeded(
-                    context.intoFunction(function), typeMapper.mapSignature(function), function, OwnerKind.IMPLEMENTATION,
+                    context.intoFunction(function), function, OwnerKind.IMPLEMENTATION,
                     new DefaultParameterValueLoader() {
                         @Override
                         public StackValue genValue(ValueParameterDescriptor valueParameter, ExpressionCodegen codegen) {
@@ -1056,8 +1056,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                    }
         );
 
-        functionCodegen.generateDefaultIfNeeded(constructorContext, typeMapper.mapSignature(constructorDescriptor), constructorDescriptor,
+        functionCodegen.generateDefaultIfNeeded(constructorContext, constructorDescriptor, OwnerKind.IMPLEMENTATION,
-                                                OwnerKind.IMPLEMENTATION, DefaultParameterValueLoader.DEFAULT, null);
+                                                DefaultParameterValueLoader.DEFAULT, null);
 
         CallableMethod callableMethod = typeMapper.mapToCallableMethod(constructorDescriptor);
         FunctionCodegen.generateConstructorWithoutParametersIfNeeded(state, callableMethod, constructorDescriptor, v, myClass);

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

@@ -190,8 +190,7 @@ public class PackageCodegen {
                         );
 
                         memberCodegen.functionCodegen.generateDefaultIfNeeded(
-                                context.intoFunction(function), state.getTypeMapper().mapSignature(function, OwnerKind.PACKAGE),
+                                context.intoFunction(function), function, OwnerKind.PACKAGE, DefaultParameterValueLoader.DEFAULT, null
-                                function, OwnerKind.PACKAGE, DefaultParameterValueLoader.DEFAULT, null
                         );
                     }
                     else if (member instanceof DeserializedPropertyDescriptor) {

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java

@@ -187,12 +187,10 @@ public class InlineCodegen extends CallGenerator {
             //for maxLocals calculation
             MethodVisitor maxCalcAdapter = InlineCodegenUtil.wrapWithMaxLocalCalc(node);
             MethodContext methodContext = context.getParentContext().intoFunction(functionDescriptor);
-            MemberCodegen<?> parentCodegen = codegen.getParentCodegen();
             if (callDefault) {
-                boolean isStatic = AsmUtil.isStaticMethod(context.getContextKind(), functionDescriptor);
                 FunctionCodegen.generateDefaultImplBody(
-                        methodContext, jvmSignature, functionDescriptor, isStatic, maxCalcAdapter, DefaultParameterValueLoader.DEFAULT,
+                        methodContext, functionDescriptor, maxCalcAdapter, DefaultParameterValueLoader.DEFAULT,
-                        (JetNamedFunction) element, parentCodegen, state
+                        (JetNamedFunction) element, codegen.getParentCodegen()
                 );
             }
             else {