[JS IR] Skip export annotations while generating default stubs

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt

@@ -235,8 +235,16 @@ private fun IrTypeParameter.copySuperTypesFrom(source: IrTypeParameter, srcToDst
     }
 }
 
+fun IrAnnotationContainer.copyAnnotations(): List<IrConstructorCall> {
+    return annotations.map { it.deepCopyWithSymbols(this as? IrDeclarationParent) }
+}
+
+fun IrAnnotationContainer.copyAnnotationsWhen(filter: IrConstructorCall.() -> Boolean): List<IrConstructorCall> {
+    return annotations.mapNotNull { if (it.filter()) it.deepCopyWithSymbols(this as? IrDeclarationParent) else null }
+}
+
 fun IrMutableAnnotationContainer.copyAnnotationsFrom(source: IrAnnotationContainer) {
-    annotations += source.annotations.map { it.deepCopyWithSymbols(this as? IrDeclarationParent) }
+    annotations += source.copyAnnotations()
 }
 
 fun makeTypeParameterSubstitutionMap(

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt

@@ -50,6 +50,8 @@ open class DefaultArgumentStubGenerator(
         return null
     }
 
+    open protected fun IrFunction.resolveAnnotations() = copyAnnotations()
+
     private fun lower(irFunction: IrFunction): List<IrFunction>? {
         val newIrFunction =
             irFunction.generateDefaultsFunction(
@@ -58,7 +60,8 @@ open class DefaultArgumentStubGenerator(
                 skipExternalMethods,
                 forceSetOverrideSymbols,
                 defaultArgumentStubVisibility(irFunction),
-                useConstructorMarker(irFunction)
+                useConstructorMarker(irFunction),
+                irFunction.resolveAnnotations()
             ) ?: return null
         if (newIrFunction.isFakeOverride) {
             return listOf(irFunction, newIrFunction)
@@ -384,7 +387,8 @@ open class DefaultParameterInjector(
                 skipExternalMethods,
                 forceSetOverrideSymbols,
                 defaultArgumentStubVisibility(declaration),
-                useConstructorMarker(declaration)
+                useConstructorMarker(declaration),
+                emptyList()
             ) ?: return null
 
         log { "$declaration -> $stubFunction" }
@@ -485,7 +489,8 @@ private fun IrFunction.generateDefaultsFunction(
     skipExternalMethods: Boolean,
     forceSetOverrideSymbols: Boolean,
     visibility: DescriptorVisibility,
-    useConstructorMarker: Boolean
+    useConstructorMarker: Boolean,
+    copiedAnnotations: List<IrConstructorCall>
 ): IrFunction? {
     if (skipInlineMethods && isInline) return null
     if (skipExternalMethods && isExternalOrInheritedFromExternal()) return null
@@ -495,7 +500,7 @@ private fun IrFunction.generateDefaultsFunction(
         // If this is an override of a function with default arguments, produce a fake override of a default stub.
         if (overriddenSymbols.any { it.owner.findBaseFunctionWithDefaultArguments(skipInlineMethods, skipExternalMethods) != null })
             return generateDefaultsFunctionImpl(
-                context, IrDeclarationOrigin.FAKE_OVERRIDE, visibility, true, useConstructorMarker
+                context, IrDeclarationOrigin.FAKE_OVERRIDE, visibility, copiedAnnotations, true, useConstructorMarker
             ).also { defaultsFunction ->
                 context.mapping.defaultArgumentsDispatchFunction[this] = defaultsFunction
                 context.mapping.defaultArgumentsOriginalFunction[defaultsFunction] = this
@@ -508,7 +513,8 @@ private fun IrFunction.generateDefaultsFunction(
                             skipExternalMethods,
                             forceSetOverrideSymbols,
                             visibility,
-                            useConstructorMarker
+                            useConstructorMarker,
+                            it.owner.copyAnnotations()
                         )?.symbol as IrSimpleFunctionSymbol?
                     }
                 }
@@ -526,7 +532,7 @@ private fun IrFunction.generateDefaultsFunction(
     // binaries, it's way too late to fix it. Hence the workaround.
     if (valueParameters.any { it.defaultValue != null }) {
         return generateDefaultsFunctionImpl(
-            context, IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER, visibility, false, useConstructorMarker
+            context, IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER, visibility, copiedAnnotations, false, useConstructorMarker
         ).also {
             context.mapping.defaultArgumentsDispatchFunction[this] = it
             context.mapping.defaultArgumentsOriginalFunction[it] = this
@@ -539,6 +545,7 @@ private fun IrFunction.generateDefaultsFunctionImpl(
     context: CommonBackendContext,
     newOrigin: IrDeclarationOrigin,
     newVisibility: DescriptorVisibility,
+    copiedAnnotations: List<IrConstructorCall>,
     isFakeOverride: Boolean,
     useConstructorMarker: Boolean
 ): IrFunction {
@@ -601,7 +608,7 @@ private fun IrFunction.generateDefaultsFunctionImpl(
     }
 
     // TODO some annotations are needed (e.g. @JvmStatic), others need different values (e.g. @JvmName), the rest are redundant.
-    newFunction.copyAnnotationsFrom(this)
+    newFunction.annotations += copiedAnnotations
     return newFunction
 }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt

@@ -326,8 +326,8 @@ class ExportModelGenerator(val context: JsIrBackendContext) {
             return Exportability.NotNeeded
         if (function.origin == IrDeclarationOrigin.BRIDGE ||
             function.origin == JsLoweredDeclarationOrigin.BRIDGE_TO_EXTERNAL_FUNCTION ||
-            function.origin == IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER ||
+            function.origin == JsLoweredDeclarationOrigin.OBJECT_GET_INSTANCE_FUNCTION ||
-            function.origin == JsLoweredDeclarationOrigin.OBJECT_GET_INSTANCE_FUNCTION
+            function.origin == IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER
         ) {
             return Exportability.NotNeeded
         }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt

@@ -7,10 +7,12 @@ package org.jetbrains.kotlin.ir.backend.js.lower
 
 import org.jetbrains.kotlin.backend.common.BodyLoweringPass
 import org.jetbrains.kotlin.backend.common.deepCopyWithVariables
+import org.jetbrains.kotlin.backend.common.ir.copyAnnotationsWhen
 import org.jetbrains.kotlin.backend.common.ir.isOverridableOrOverrides
 import org.jetbrains.kotlin.backend.common.lower.DefaultArgumentStubGenerator
 import org.jetbrains.kotlin.backend.common.lower.DEFAULT_DISPATCH_CALL
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
+import org.jetbrains.kotlin.ir.backend.js.utils.JsAnnotations
 import org.jetbrains.kotlin.ir.builders.IrBlockBodyBuilder
 import org.jetbrains.kotlin.ir.builders.irCall
 import org.jetbrains.kotlin.ir.builders.irGet
@@ -20,6 +22,7 @@ import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl
 import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols
+import org.jetbrains.kotlin.ir.util.isAnnotation
 import org.jetbrains.kotlin.ir.util.patchDeclarationParents
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid
@@ -29,6 +32,10 @@ class JsDefaultArgumentStubGenerator(override val context: JsIrBackendContext) :
 
     override fun needSpecialDispatch(irFunction: IrSimpleFunction) = irFunction.isOverridableOrOverrides
 
+    override fun IrFunction.resolveAnnotations(): List<IrConstructorCall> = copyAnnotationsWhen {
+        !(isAnnotation(JsAnnotations.jsExportFqn) || isAnnotation(JsAnnotations.jsNameFqn))
+    }
+
     override fun IrBlockBodyBuilder.generateHandleCall(
         handlerDeclaration: IrValueParameter,
         oldIrFunction: IrFunction,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -279,10 +279,10 @@ tailrec fun IrElement.getPackageFragment(): IrPackageFragment? {
     }
 }
 
+fun IrConstructorCall.isAnnotation(name: FqName) = symbol.owner.parentAsClass.fqNameWhenAvailable == name
+
 fun IrAnnotationContainer.getAnnotation(name: FqName): IrConstructorCall? =
-    annotations.find {
+    annotations.find { it.isAnnotation(name) }
-        it.symbol.owner.parentAsClass.fqNameWhenAvailable == name
-    }
 
 fun IrAnnotationContainer.hasAnnotation(name: FqName) =
     annotations.any {