paren(expression)
    }

    val valueArgument by debug {
        optional(annotation) * optional(simpleIdentifier * token(EQ)) * optional(token(MUL)) * expression
    }

    val valueArguments by debug {
        paren(
            optional(
                valueArgument * zeroOrMore(token(COMMA) * valueArgument) * optional(token(COMMA))
            )
        )
    }

                        }
                    }
                    val valueArguments = expression.valueArguments
                    require(valueArguments.size == 2) {
                        "Illegal call of ${expression.name} at ${expression.positionString}"
                    }

                    val a = valueArguments[0]
                    val aType = a.getArgumentExpression()?.getKaType()

        return elementOrFailure {
            val arguments = valueArguments.flatMap { valueArguments(tree, it) }.map { checkForFailure(it) }
            elementIfNoFailures {
                Element(FunctionCall(null, name!!, arguments.map(::checked), tree.sourceData(node)))
            }
        }
    }

    private
    fun valueArguments(tree: CachingLightTree, node: LighterASTNode): List<SyntacticResult<FunctionArgument>> {

                if (element.isNamed()) return@provider null
                val annotationEntry = element.getParentOfTypeAndBranch<KtAnnotationEntry> { valueArgumentList } ?: return@provider null
                if (annotationEntry.valueArguments.size != 1) return@provider null

                KtDefaultAnnotationArgumentReference(element)
            }
        }
    }

            // ResolvedCall.valueArguments have their names affected by the `@ParameterName` annotations,
            // so we use `name` instead of `symbol.name`
            it.name
        }
        val result = LinkedHashMap<KtExpression, KaVariableLikeSignature<KaValueParameterSymbol>>()
        for ((parameter, arguments) in valueArguments) {

    ): ObjectOrigin.FunctionOrigin? = with(context) {
        val argResolutions = lazy {
            var hasErrors = false
            val result = buildMap<FunctionArgument.ValueArgument, ObjectOrigin> {
                functionCall.args.filterIsInstance<FunctionArgument.ValueArgument>().forEach {
                    val resolution = expressionResolver.doResolveExpression(context, it.expr)
                    if (resolution == null) {

}


sealed interface FunctionArgument : LanguageTreeElement {
    sealed interface ValueArgument : FunctionArgument {
        val expr: Expr
    }

    data class Positional(override val expr: Expr, override val sourceData: SourceData) : ValueArgument
    data class Named(val name: String, override val expr: Expr, override val sourceData: SourceData) : ValueArgument

            append("}".withIndent(context))
        }
    }

    override fun convertType(type: KType): KType {
        val keyArgument = type.arguments[0]
        val valueArgument = type.arguments[1]
        return Map::class.createType(
            arguments = listOf(
                KTypeProjection(
                    variance = KVariance.INVARIANT,

        } ?: return null
        val callExpression =
            (valueArgument.parent as? KtValueArgumentList)?.parent as? KtCallElement
                ?: valueArgument.parent as? KtCallElement // KtLambdaArgument
                ?: return null
        val argumentExpression = valueArgument.getArgumentExpression() ?: return null
        return KtCallWithArgument(callExpression, argumentExpression)
    }

            is PropertyAccess -> current.receiver?.let(::collectFrom)
            is LocalValue -> collectFrom(current.rhs)
            is FunctionArgument.Lambda -> collectFrom(current.block)
            is FunctionArgument.ValueArgument -> collectFrom(current.expr)

            is Import,
            is Literal<*>,
            is Null,
            is This -> Unit
        }
    }

    results.forEach {
        when (it) {