Update logic to $default function lowering (don't skip interface members)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt

@@ -71,14 +71,16 @@ open class FunctionCodegen(private val irFunction: IrFunction, private val class
     }
 
     private fun calculateMethodFlags(isStatic: Boolean): Int {
+        if (irFunction.origin == DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER) {
+            return Opcodes.ACC_PUBLIC or Opcodes.ACC_SYNTHETIC.let {
+                if (irFunction is IrConstructor) it else it or Opcodes.ACC_BRIDGE or Opcodes.ACC_STATIC
+            }
+        }
+
         var flags = AsmUtil.getMethodAsmFlags(descriptor, OwnerKind.IMPLEMENTATION, state).or(if (isStatic) Opcodes.ACC_STATIC else 0).xor(
             if (classCodegen.irClass.isAnnotationClass) Opcodes.ACC_FINAL else 0/*TODO*/
         ).or(if (descriptor is JvmDescriptorWithExtraFlags) descriptor.extraFlags else 0)
 
-        if (irFunction.origin == DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER) {
-            flags = flags.xor(AsmUtil.getVisibilityAccessFlag(descriptor)).or(Opcodes.ACC_PUBLIC)
-        }
-
         if (classCodegen.irClass.isJvmInterface && InitializersLowering.clinitName == irFunction.name) {
             //reset abstract flag for <clinit>
             flags = flags.xor(Opcodes.ACC_ABSTRACT)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/InterfaceLowering.kt

@@ -31,9 +31,11 @@ import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.util.createParameterDeclarations
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -60,10 +62,12 @@ class InterfaceLowering(val state: GenerationState) : IrElementTransformerVoid()
 
         irClass.declarations.filterIsInstance<IrFunction>().forEach {
             val descriptor = it.descriptor
-            if (descriptor.modality != Modality.ABSTRACT) {
+            if (it.origin == DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER) {
+                members.add(it) //just copy $default to DefaultImpls
+            } else if (descriptor.modality != Modality.ABSTRACT) {
                 val functionDescriptorImpl =
                     createDefaultImplFunDescriptor(defaultImplsDescriptor, descriptor, interfaceDescriptor, state.typeMapper)
-                members.add(functionDescriptorImpl.createFunctionAndMapVariables(it))
+                members.add(functionDescriptorImpl.createFunctionAndMapVariables(it, it.visibility))
                 it.body = null
             }
         }
@@ -142,8 +146,15 @@ internal fun createStaticFunctionWithReceivers(
     return newFunction
 }
 
-internal fun FunctionDescriptor.createFunctionAndMapVariables(oldFunction: IrFunction) =
+internal fun FunctionDescriptor.createFunctionAndMapVariables(
-    IrFunctionImpl(oldFunction.startOffset, oldFunction.endOffset, oldFunction.origin, this, oldFunction.body).apply {
+    oldFunction: IrFunction,
+    visibility: Visibility
+) =
+    IrFunctionImpl(
+        oldFunction.startOffset, oldFunction.endOffset, oldFunction.origin, IrSimpleFunctionSymbolImpl(this),
+        visibility = visibility
+    ).apply {
+        body = oldFunction.body
         createParameterDeclarations()
         val mapping: Map<ValueDescriptor, IrValueParameter> =
             (

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/StaticDefaultFunctionLowering.kt

@@ -18,9 +18,9 @@ package org.jetbrains.kotlin.backend.jvm.lower
 
 import org.jetbrains.kotlin.backend.common.ClassLoweringPass
 import org.jetbrains.kotlin.backend.common.lower.DECLARATION_ORIGIN_FUNCTION_FOR_DEFAULT_PARAMETER
-import org.jetbrains.kotlin.backend.jvm.codegen.isJvmInterface
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFunction
@@ -29,9 +29,6 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 class StaticDefaultFunctionLowering(val state: GenerationState) : IrElementTransformerVoid(), ClassLoweringPass {
 
     override fun lower(irClass: IrClass) {
-        if (irClass.isJvmInterface) {
-            return
-        }
         irClass.accept(this, null)
     }
 
@@ -43,7 +40,7 @@ class StaticDefaultFunctionLowering(val state: GenerationState) : IrElementTrans
                 declaration.descriptor,
                 declaration.descriptor.dispatchReceiverParameter!!.type
             )
-            newFunction.createFunctionAndMapVariables(declaration)
+            newFunction.createFunctionAndMapVariables(declaration, Visibilities.PUBLIC)
         } else {
             super.visitFunction(declaration)
         }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt

@@ -34,35 +34,18 @@ class IrFunctionImpl(
     endOffset: Int,
     origin: IrDeclarationOrigin,
     override val symbol: IrSimpleFunctionSymbol,
-    name: Name,
+    name: Name = symbol.descriptor.name,
-    visibility: Visibility,
+    visibility: Visibility = symbol.descriptor.visibility,
-    override val modality: Modality,
+    override val modality: Modality = symbol.descriptor.modality,
-    returnType: KotlinType,
+    returnType: KotlinType = symbol.descriptor.returnType!!,
-    isInline: Boolean,
+    isInline: Boolean = symbol.descriptor.isInline,
-    isExternal: Boolean,
+    isExternal: Boolean = symbol.descriptor.isExternal,
-    override val isTailrec: Boolean,
+    override val isTailrec: Boolean = symbol.descriptor.isTailrec,
-    override val isSuspend: Boolean
+    override val isSuspend: Boolean = symbol.descriptor.isSuspend
 ) :
     IrFunctionBase(startOffset, endOffset, origin, name, visibility, isInline, isExternal, returnType),
     IrSimpleFunction {
 
-    constructor(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin,
-        symbol: IrSimpleFunctionSymbol
-    ) : this(
-        startOffset, endOffset, origin, symbol,
-        symbol.descriptor.name,
-        symbol.descriptor.visibility,
-        symbol.descriptor.modality,
-        symbol.descriptor.returnType!!,
-        symbol.descriptor.isInline,
-        symbol.descriptor.isExternal,
-        symbol.descriptor.isTailrec,
-        symbol.descriptor.isSuspend
-    )
-
     override val descriptor: FunctionDescriptor = symbol.descriptor
 
     override val overriddenSymbols: MutableList<IrSimpleFunctionSymbol> = SmartList()