Method eval

source/ast/builtins/ArrayMethods.cpp:148–207

    }

    ConstantValue eval(EvalContext& context, const Args& args, SourceRange,
                       const CallExpression::SystemCallInfo& callInfo) const final {
        auto lval = args[0]->evalLValue(context);
        if (!lval)
            return nullptr;

        auto target = lval.resolve();
        if (!target)
            return nullptr;

        auto [iterExpr, iterVar] = callInfo.getIteratorInfo();
        if (iterExpr) {
            SLANG_ASSERT(iterVar);
            auto guard = context.disableCaching();
            auto iterVal = context.createLocal(iterVar);

            auto sortTarget = [&, ie = iterExpr](auto& target) {
                auto pred = [&, ie = ie](ConstantValue& a, ConstantValue& b) {
                    *iterVal = a;
                    ConstantValue cva = ie->eval(context);

                    *iterVal = b;
                    ConstantValue cvb = ie->eval(context);

                    return cva < cvb;
                };

                if (reversed)
                    std::ranges::sort(target.rbegin(), target.rend(), pred);
                else
                    std::ranges::sort(target, pred);
            };

            if (target->isQueue()) {
                sortTarget(*target->queue());
            }
            else {
                auto& vec = std::get<ConstantValue::Elements>(target->getVariant());
                sortTarget(vec);
            }
        }
        else {
            auto sortTarget = [&](auto& target) {
                if (reversed)
                    std::ranges::sort(target.rbegin(), target.rend(), std::less<>{});
                else
                    std::ranges::sort(target, std::less<>{});
            };

            if (target->isQueue()) {
                sortTarget(*target->queue());
            }
            else {
                auto& vec = std::get<ConstantValue::Elements>(target->getVariant());
                sortTarget(vec);
            }
        }