Minor: renaming

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

@@ -216,7 +216,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
         return InnerClassConsumer.Companion.classForInnerClassRecord(descriptor, false);
     }
 
-    protected void generateTraitMethods() {
+    protected void generateDelegatesToDefaultImpl() {
         if (isJvmInterface(descriptor)) return;
 
         for (Map.Entry<FunctionDescriptor, FunctionDescriptor> entry : CodegenUtil.getNonPrivateTraitMethods(descriptor).entrySet()) {
@@ -271,47 +271,48 @@ public abstract class ClassBodyCodegen extends MemberCodegen<KtPureClassOrObject
                     private void putArgumentsOnStack(
                             @NotNull ExpressionCodegen codegen,
                             @NotNull JvmMethodSignature signature,
-                            Method traitMethod
+                            @NotNull Method defaultImplsMethod
                     ) {
                         InstructionAdapter iv = codegen.v;
-                        Type[] argTypes = signature.getAsmMethod().getArgumentTypes();
+                        Type[] myArgTypes = signature.getAsmMethod().getArgumentTypes();
-                        Type[] originalArgTypes = traitMethod.getArgumentTypes();
+                        Type[] toArgTypes = defaultImplsMethod.getArgumentTypes();
                         boolean isErasedInlineClass =
                                 InlineClassesUtilsKt.isInlineClass(descriptor) && kind == OwnerKind.ERASED_INLINE_CLASS;
 
-                        int argI = 0;
+                        int myArgI = 0;
-                        int reg = 0;
+                        int argVar = 0;
 
                         Type receiverType = typeMapper.mapType(descriptor);
                         KotlinType interfaceKotlinType = ((ClassDescriptor) inheritedFun.getContainingDeclaration()).getDefaultType();
-                        StackValue.local(reg, receiverType, descriptor.getDefaultType()).put(OBJECT_TYPE, interfaceKotlinType, iv);
+                        StackValue.local(argVar, receiverType, descriptor.getDefaultType())
-                        if (isErasedInlineClass) argI++;
+                                .put(OBJECT_TYPE, interfaceKotlinType, iv);
-                        reg += receiverType.getSize();
+                        if (isErasedInlineClass) myArgI++;
+                        argVar += receiverType.getSize();
 
-                        int originalArgI = 1;
+                        int toArgI = 1;
 
-                        List<ParameterDescriptor> argsDescriptors = getParameters(inheritedFun);
+                        List<ParameterDescriptor> myParameters = getParameters(inheritedFun);
-                        List<ParameterDescriptor> originalArgsDescriptors = getParameters(interfaceFun);
+                        List<ParameterDescriptor> toParameters = getParameters(interfaceFun);
-                        assert argsDescriptors.size() == originalArgsDescriptors.size() :
+                        assert myParameters.size() == toParameters.size() :
                                 "Inconsistent value parameters between delegating fun " + inheritedFun +
                                 "and interface fun " + interfaceFun;
 
-                        Iterator<ParameterDescriptor> argsIterator = argsDescriptors.iterator();
+                        Iterator<ParameterDescriptor> myParametersIterator = myParameters.iterator();
-                        Iterator<ParameterDescriptor> originalArgsIterator = originalArgsDescriptors.iterator();
+                        Iterator<ParameterDescriptor> toParametersIterator = toParameters.iterator();
-                        for (; argI < argTypes.length; argI++, originalArgI++) {
+                        for (; myArgI < myArgTypes.length; myArgI++, toArgI++) {
-                            Type argType = argTypes[argI];
+                            Type argType = myArgTypes[myArgI];
-                            KotlinType argKotlinType = argsIterator.next().getType();
+                            KotlinType argKotlinType = myParametersIterator.next().getType();
 
-                            Type originalArgType = originalArgTypes[originalArgI];
+                            Type originalArgType = toArgTypes[toArgI];
-                            KotlinType originalArgKotlinType = originalArgsIterator.next().getType();
+                            KotlinType originalArgKotlinType = toParametersIterator.next().getType();
 
-                            StackValue.local(reg, argType, argKotlinType)
+                            StackValue.local(argVar, argType, argKotlinType)
                                     .put(originalArgType, originalArgKotlinType, iv);
-                            reg += argType.getSize();
+                            argVar += argType.getSize();
                         }
 
-                        assert originalArgI == originalArgTypes.length :
+                        assert toArgI == toArgTypes.length :
-                                "Invalid trait implementation signature: " + signature + " vs " + traitMethod + " for " + interfaceFun;
+                                "Invalid trait implementation signature: " + signature + " vs " + defaultImplsMethod + " for " + interfaceFun;
                     }
 
                     private List<ParameterDescriptor> getParameters(FunctionDescriptor functionDescriptor) {

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

@@ -49,7 +49,7 @@ class ErasedInlineClassBodyCodegen(
     override fun generateSyntheticPartsAfterBody() {
         super.generateSyntheticPartsAfterBody()
 
-        generateTraitMethods()
+        generateDelegatesToDefaultImpl()
         generateUnboxMethod()
         generateFunctionsFromAny()
         generateSpecializedEqualsStub()

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

@@ -13,7 +13,6 @@ import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function2;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.backend.common.CodegenUtil;
 import org.jetbrains.kotlin.backend.common.DataClassMethodGenerator;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap;
@@ -73,9 +72,7 @@ import static org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
-import static org.jetbrains.kotlin.resolve.jvm.annotations.JvmAnnotationUtilKt.hasJvmDefaultAnnotation;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
-import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL;
 import static org.jetbrains.kotlin.types.Variance.INVARIANT;
 import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isLocalFunction;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
@@ -411,7 +408,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         generateCompanionObjectBackingFieldCopies();
 
-        generateTraitMethods();
+        generateDelegatesToDefaultImpl();
 
         generateDelegates(delegationFieldsInfo);