): 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,

        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))
            )
        )
    }

            }
        }


    private
    fun valueArgument(tree: CachingLightTree, node: LighterASTNode): SyntacticResult<FunctionArgument.ValueArgument> =
        syntacticOrFailure {
            if (node.tokenType == PARENTHESIZED) return@syntacticOrFailure valueArgument(tree, tree.getFirstChildExpressionUnwrapped(node)!!)

        } ?: 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) {

            resolver
        )

        val call = result.errors.first { it.errorReason is ErrorReason.UnresolvedFunctionCallSignature }.element as FunctionCall
        val arg = (call.args[0] as FunctionArgument.ValueArgument).expr

        val outerErrors = assertNotNull(resolver.trace.expressionResolution(call).errors)
        assertEquals(2, outerErrors.size)
        assertEquals(

                val valueArgument = varargArgument.findSourceKtExpressionForCallArgument() ?: return
                argumentMapping[valueArgument] = parameterSymbol
            }
        } else {
            val valueArgument = argumentExpression.findSourceKtExpressionForCallArgument() ?: return
            argumentMapping[valueArgument] = parameterSymbol
        }
    }