Make test tag template configurable

[digitalbuddha]

Hello thank you for the nice library. Is there a way we can make the test tag generation configurable? For example I am using the tags with maestro (mobile.dev) which struggle with current format. I'd love the ability to remove special characters and the numeric/offset markers. Thank you

[0xera]

Hi. Great idea. I will do it

[digitalbuddha]

Wonderful thank you as I am 2 hours into trying to fork and update myself 😅
As another note, I'm not sure if the offset numbers are scalable, I expect test tags to not change if new things are added to a file. Maybe you can use a combination of the element's index within its parent and the parent's unique identifier. This way, the tags will remain consistent even if new code is added to the same composable.

Chatgpt rework (not sure if correct as I still can't fully get compiling)

package com.vk.compiler.plugin.compose.test.tag.applier

import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext
import org.jetbrains.kotlin.backend.common.serialization.mangle.ir.isAnonymous
import org.jetbrains.kotlin.ir.IrStatement
import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
import org.jetbrains.kotlin.ir.declarations.IrFile
import org.jetbrains.kotlin.ir.declarations.IrFunction
import org.jetbrains.kotlin.ir.declarations.IrValueParameter
import org.jetbrains.kotlin.ir.declarations.IrVariable
import org.jetbrains.kotlin.ir.declarations.name
import org.jetbrains.kotlin.ir.expressions.IrBlock
import org.jetbrains.kotlin.ir.expressions.IrCall
import org.jetbrains.kotlin.ir.expressions.IrExpression
import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
import org.jetbrains.kotlin.ir.expressions.IrGetValue
import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
import org.jetbrains.kotlin.ir.expressions.impl.IrGetObjectValueImpl
import org.jetbrains.kotlin.ir.interpreter.toIrConst
import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
import org.jetbrains.kotlin.ir.types.IrType
import org.jetbrains.kotlin.ir.types.classFqName
import org.jetbrains.kotlin.ir.types.defaultType
import org.jetbrains.kotlin.ir.util.dumpKotlinLike
import org.jetbrains.kotlin.ir.util.hasAnnotation
import org.jetbrains.kotlin.ir.util.isVararg
import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.utils.addToStdlib.popLast

internal class TestTagApplier(
    private val pluginContext: IrPluginContext
) : IrElementTransformerVoid() {

    private val transformedCalls = mutableSetOf<IrCall>()

    private val modifierObjectClass by lazy {
        pluginContext.referenceClass(modifierObjectClassId)
    }

    private val thenFunction by lazy {
        pluginContext.referenceFunctions(thenFuncCallableId).firstOrNull()?.owner?.symbol
    }

    private val applyTagFunction by lazy {
        pluginContext.referenceFunctions(applyTagCallableId).firstOrNull()?.owner?.symbol
    }

    private val functionsStack = mutableListOf<IrFunction>()
    private val filesStack = mutableListOf<IrFile>()

    override fun visitFile(declaration: IrFile): IrFile {
        filesStack += declaration
        val result = super.visitFile(declaration)
        filesStack.popLast()
        return result
    }

    override fun visitFunction(declaration: IrFunction): IrStatement {
        functionsStack += declaration
        val result = super.visitFunction(declaration)
        functionsStack.popLast()
        return result
    }

    override fun visitCall(expression: IrCall): IrExpression =
        super.visitCall(expression.applyTestTagToModifier())


    private fun IrCall.applyTestTagToModifier(): IrCall {
        val applyTagFunction = applyTagFunction
        val lastFile = filesStack.lastOrNull()
        val lastFunction = functionsStack.lastOrNull()?.searchNotAnonymous()

        if (applyTagFunction == null || lastFile == null || lastFunction == null) return this

        if (!symbol.owner.isComposable() || this in transformedCalls) return this

        transformedCalls += this

        return transformModifierArguments(applyTagFunction, lastFile, lastFunction)

    }

    private fun IrCall.transformModifierArguments(
        applyTagFunction: IrSimpleFunctionSymbol,
        lastFile: IrFile,
        lastFunction: IrFunction
    ): IrCall {

        repeat(valueArgumentsCount) { index ->
            val parameter = symbol.owner.valueParameters[index]
            val argumentExpression = retrieveArgumentExpression(parameter, getValueArgument(index))

            if (argumentExpression?.containsModifierWithTestTag() == false && !parameter.isVararg && parameter.isMainComposeModifier()) {

                val modifiedArgumentExpression = modifyExpressionForTestTag(
                    argumentExpression,
                    parameter,
                    applyTagFunction,
                    createTag(this, lastFile, lastFunction, index)
                )
                if (modifiedArgumentExpression != null) putValueArgument(
                    index,
                    modifiedArgumentExpression
                )
            }
        }
        return this
    }

    private fun modifyExpressionForTestTag(
        argumentExpression: IrExpression,
        parameter: IrValueParameter,
        applyTagFunction: IrSimpleFunctionSymbol,
        tag: String
    ): IrExpression? {

        return when (argumentExpression) {
            is IrGetValue -> modifyIrGetValue(argumentExpression, parameter, tag, applyTagFunction)
            is IrCall -> modifyIrCall(argumentExpression, parameter, tag, applyTagFunction)
            is IrGetObjectValue -> modifierIrGetObject(argumentExpression, parameter, applyTagFunction, tag)
            else -> null
        }

    }

    private fun modifyIrGetValue(
        argumentExpression: IrGetValue,
        parameter: IrValueParameter,
        tag: String,
        applyTagFunction: IrSimpleFunctionSymbol
    ): IrExpression? {
        if (argumentExpression.symbol.owner.origin != IrDeclarationOrigin.IR_TEMPORARY_VARIABLE) return null

        val variable = argumentExpression.symbol.owner as? IrVariable
        val variableInitializer = variable?.initializer

        if (variableInitializer?.containsModifierWithTestTag() == true) return null

        return when {
            variableInitializer?.type?.isComposeModifierObject() == true -> {

                val modifierObjectClass = modifierObjectClass ?: return null

                val modifierObject = IrGetObjectValueImpl(
                    startOffset = UNDEFINED_OFFSET,
                    endOffset = UNDEFINED_OFFSET,
                    type = modifierObjectClass.defaultType,
                    symbol = modifierObjectClass
                )
                modifierIrGetObject(modifierObject, parameter, applyTagFunction, tag)
            }

            variableInitializer is IrBlock -> {
                val lastStatement = variableInitializer.statements.lastOrNull() as? IrExpression
                if (lastStatement != null) {
                    val modifiedStatement =
                        modifyExpressionForTestTag(lastStatement, parameter, applyTagFunction, tag)
                    if (modifiedStatement != null) {
                        variableInitializer.statements[variableInitializer.statements.lastIndex] = modifiedStatement
                    }
                }
                null
            }

            variableInitializer != null -> {
                val modifierInitializer =
                    modifyExpressionForTestTag(variableInitializer, parameter, applyTagFunction, tag)
                if (modifierInitializer != null) {
                    variable.initializer = modifierInitializer
                }
                null
            }
            else -> null
        }
    }

    private fun modifierIrGetObject(
        argumentExpression: IrExpression,
        parameter: IrValueParameter,
        applyTagFunction: IrSimpleFunctionSymbol,
        tag: String
    ): IrCallImpl? {
        if (argumentExpression.type.isComposeModifierObject().not()) return null

        return IrCallImpl(
            startOffset = UNDEFINED_OFFSET,
            endOffset = UNDEFINED_OFFSET,
            type = parameter.type,
            symbol = applyTagFunction,
            typeArgumentsCount = 0,
            valueArgumentsCount = 1,
        ).apply {
            extensionReceiver = argumentExpression
            putValueArgument(0, tag.toIrConst(pluginContext.irBuiltIns.stringType))
        }
    }

    private fun modifyIrCall(
        argumentExpression: IrCall,
        parameter: IrValueParameter,
        tag: String,
        applyTagFunction: IrSimpleFunctionSymbol
    ): IrExpression? {

        val topmostReceiverCall = argumentExpression.getTopmostReceiverCall()
        val topmostReceiverObject = topmostReceiverCall.extensionReceiver ?: topmostReceiverCall.dispatchReceiver

        if (topmostReceiverObject is IrGetValue) {
            return modifyExpressionChainForIrGetValue(
                argumentExpression,
                parameter,
                applyTagFunction,
                tag,
                topmostReceiverObject
            )
        }

        return modifyExpressionChain(argumentExpression, parameter, applyTagFunction, tag, topmostReceiverObject)
    }

    private fun modifyExpressionChain(
        argumentExpression: IrCall,
        parameter: IrValueParameter,
        applyTagFunction: IrSimpleFunctionSymbol,
        tag: String,
        topmostReceiverObject: IrExpression?
    ): IrCallImpl? {

        if (topmostReceiverObject?.type?.isComposeModifierObject() != true) return null

        val thenFunction = thenFunction
        val modifierObjectClass = modifierObjectClass

        if (thenFunction == null || modifierObjectClass == null) return null

        val modifierObject = IrGetObjectValueImpl(
            startOffset = UNDEFINED_OFFSET,
            endOffset = UNDEFINED_OFFSET,
            type = modifierObjectClass.defaultType,
            symbol = modifierObjectClass
        )

        val applyTagCall = IrCallImpl(
            startOffset = UNDEFINED_OFFSET,
            endOffset = UNDEFINED_OFFSET,
            type = parameter.type,
            symbol = applyTagFunction,
            typeArgumentsCount = 0,
            valueArgumentsCount = 1,
        ).apply {
            extensionReceiver = modifierObject
            putValueArgument(0, tag.toIrConst(pluginContext.irBuiltIns.stringType))
        }

        return IrCallImpl(
            startOffset = UNDEFINED_OFFSET,
            endOffset = UNDEFINED_OFFSET,

[0xera]

Could you tell, please, which format would be better?

[digitalbuddha]

Strip all non alphanumeric, use spaces to delimit. Allow configuration to say how many parents/ancestors to consider in naming for example I want 3 layers In each name. Allow configuration to say whether to include position in parent for just current node or parent nodes as well or no positions included at all. I believe that would fill my use case

[0xera]

Allow configuration to say how many parents/ancestors to consider in naming for example I want 3 layers In each name

In 3 layers do you mean filename, outer function and calling function?

[digitalbuddha]

I meant calling function along with caller of calling function and that functions caller. I'm hoping to have almost an xpath of sorts