eyg_ir

-module(eyg@ir@dag_json).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/eyg/ir/dag_json.gleam").
-export([decoder/1, decode/1, from_block/1, to_data_model/1, to_block/1, to_string/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-file("src/eyg/ir/dag_json.gleam", 10).
-spec label_decoder(fun((binary()) -> eyg@ir@tree:expression(ETI)), ETI) -> gleam@dynamic@decode:decoder({eyg@ir@tree:expression(ETI),
    ETI}).
label_decoder(For, Meta) ->
    gleam@dynamic@decode:field(
        <<"l"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Label) -> gleam@dynamic@decode:success({For(Label), Meta}) end
    ).

-file("src/eyg/ir/dag_json.gleam", 60).
?DOC(" create a decoder that will parse JSON source to an annotated tree with the given metadata.\n").
-spec decoder(ETM) -> gleam@dynamic@decode:decoder({eyg@ir@tree:expression(ETM),
    ETM}).
decoder(Meta) ->
    gleam@dynamic@decode:field(
        <<"0"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Switch) -> case Switch of
                <<"v"/utf8>> ->
                    label_decoder(fun(Field@0) -> {variable, Field@0} end, Meta);

                <<"f"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"l"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        fun(Label) ->
                            gleam@dynamic@decode:field(
                                <<"b"/utf8>>,
                                decoder(Meta),
                                fun(Body) ->
                                    gleam@dynamic@decode:success(
                                        {{lambda, Label, Body}, Meta}
                                    )
                                end
                            )
                        end
                    );

                <<"a"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"f"/utf8>>,
                        decoder(Meta),
                        fun(Function) ->
                            gleam@dynamic@decode:field(
                                <<"a"/utf8>>,
                                decoder(Meta),
                                fun(Argument) ->
                                    gleam@dynamic@decode:success(
                                        {{apply, Function, Argument}, Meta}
                                    )
                                end
                            )
                        end
                    );

                <<"l"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"l"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        fun(Label@1) ->
                            gleam@dynamic@decode:field(
                                <<"v"/utf8>>,
                                decoder(Meta),
                                fun(Value) ->
                                    gleam@dynamic@decode:field(
                                        <<"t"/utf8>>,
                                        decoder(Meta),
                                        fun(Then) ->
                                            gleam@dynamic@decode:success(
                                                {{'let', Label@1, Value, Then},
                                                    Meta}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    );

                <<"x"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"v"/utf8>>,
                        dag_json:decode_bytes(),
                        fun(Bytes) ->
                            gleam@dynamic@decode:success(
                                {{binary, Bytes}, Meta}
                            )
                        end
                    );

                <<"i"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"v"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_int/1},
                        fun(Value@1) -> case eyg@ir@integer:is_safe(Value@1) of
                                true ->
                                    gleam@dynamic@decode:success(
                                        {{integer, Value@1}, Meta}
                                    );

                                false ->
                                    gleam@dynamic@decode:failure(
                                        {vacant, Meta},
                                        <<"an exactly representable integer"/utf8>>
                                    )
                            end end
                    );

                <<"s"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"v"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        fun(Value@2) ->
                            gleam@dynamic@decode:success(
                                {{string, Value@2}, Meta}
                            )
                        end
                    );

                <<"ta"/utf8>> ->
                    gleam@dynamic@decode:success({tail, Meta});

                <<"c"/utf8>> ->
                    gleam@dynamic@decode:success({cons, Meta});

                <<"z"/utf8>> ->
                    gleam@dynamic@decode:success({vacant, Meta});

                <<"u"/utf8>> ->
                    gleam@dynamic@decode:success({empty, Meta});

                <<"e"/utf8>> ->
                    label_decoder(fun(Field@0) -> {extend, Field@0} end, Meta);

                <<"g"/utf8>> ->
                    label_decoder(fun(Field@0) -> {select, Field@0} end, Meta);

                <<"o"/utf8>> ->
                    label_decoder(
                        fun(Field@0) -> {overwrite, Field@0} end,
                        Meta
                    );

                <<"t"/utf8>> ->
                    label_decoder(fun(Field@0) -> {tag, Field@0} end, Meta);

                <<"m"/utf8>> ->
                    label_decoder(fun(Field@0) -> {'case', Field@0} end, Meta);

                <<"n"/utf8>> ->
                    gleam@dynamic@decode:success({no_cases, Meta});

                <<"p"/utf8>> ->
                    label_decoder(fun(Field@0) -> {perform, Field@0} end, Meta);

                <<"h"/utf8>> ->
                    label_decoder(fun(Field@0) -> {handle, Field@0} end, Meta);

                <<"b"/utf8>> ->
                    label_decoder(fun(Field@0) -> {builtin, Field@0} end, Meta);

                <<"#"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"l"/utf8>>,
                        dag_json:decode_cid(),
                        fun(Cid) ->
                            gleam@dynamic@decode:success(
                                {{content_reference, Cid}, Meta}
                            )
                        end
                    );

                <<"@"/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"p"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        fun(Package) ->
                            gleam@dynamic@decode:field(
                                <<"r"/utf8>>,
                                {decoder, fun gleam@dynamic@decode:decode_int/1},
                                fun(Version) ->
                                    gleam@dynamic@decode:field(
                                        <<"l"/utf8>>,
                                        dag_json:decode_cid(),
                                        fun(Cid@1) ->
                                            gleam@dynamic@decode:success(
                                                {{release_reference,
                                                        Package,
                                                        Version,
                                                        Cid@1},
                                                    Meta}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    );

                <<"."/utf8>> ->
                    gleam@dynamic@decode:field(
                        <<"i"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        fun(Location) ->
                            gleam@dynamic@decode:success(
                                {{relative_reference, Location}, Meta}
                            )
                        end
                    );

                _ ->
                    gleam@dynamic@decode:failure(
                        {vacant, Meta},
                        <<"valid node key"/utf8>>
                    )
            end end
    ).

-file("src/eyg/ir/dag_json.gleam", 134).
-spec decode(gleam@dynamic:dynamic_()) -> {ok,
        {eyg@ir@tree:expression(nil), nil}} |
    {error, list(gleam@dynamic@decode:decode_error())}.
decode(Json) ->
    gleam@dynamic@decode:run(Json, decoder(nil)).

-file("src/eyg/ir/dag_json.gleam", 141).
-spec from_block(bitstring()) -> {ok, {eyg@ir@tree:expression(nil), nil}} |
    {error, gleam@json:decode_error()}.
from_block(Data) ->
    gleam@json:parse_bits(Data, decoder(nil)).

-file("src/eyg/ir/dag_json.gleam", 145).
-spec node(binary(), list({binary(), gleam@json:json()})) -> gleam@json:json().
node(Name, Attributes) ->
    dag_json:object(
        [{<<"0"/utf8>>, fun gleam@json:string/1(Name)} | Attributes]
    ).

-file("src/eyg/ir/dag_json.gleam", 149).
-spec label(binary()) -> {binary(), gleam@json:json()}.
label(Value) ->
    {<<"l"/utf8>>, fun gleam@json:string/1(Value)}.

-file("src/eyg/ir/dag_json.gleam", 153).
-spec to_data_model({eyg@ir@tree:expression(ETX), ETX}) -> gleam@json:json().
to_data_model(Tree) ->
    {Exp, _} = Tree,
    case Exp of
        {variable, X} ->
            node(<<"v"/utf8>>, [label(X)]);

        {lambda, X@1, Body} ->
            node(
                <<"f"/utf8>>,
                [label(X@1), {<<"b"/utf8>>, to_data_model(Body)}]
            );

        {apply, Func, Arg} ->
            node(
                <<"a"/utf8>>,
                [{<<"f"/utf8>>, to_data_model(Func)},
                    {<<"a"/utf8>>, to_data_model(Arg)}]
            );

        {'let', X@2, Value, Then} ->
            _pipe = [label(X@2),
                {<<"v"/utf8>>, to_data_model(Value)},
                {<<"t"/utf8>>, to_data_model(Then)}],
            node(<<"l"/utf8>>, _pipe);

        {binary, B} ->
            node(<<"x"/utf8>>, [{<<"v"/utf8>>, dag_json:binary(B)}]);

        {integer, I} ->
            node(<<"i"/utf8>>, [{<<"v"/utf8>>, fun gleam@json:int/1(I)}]);

        {string, S} ->
            node(<<"s"/utf8>>, [{<<"v"/utf8>>, fun gleam@json:string/1(S)}]);

        tail ->
            node(<<"ta"/utf8>>, []);

        cons ->
            node(<<"c"/utf8>>, []);

        vacant ->
            node(<<"z"/utf8>>, []);

        empty ->
            node(<<"u"/utf8>>, []);

        {extend, X@3} ->
            node(<<"e"/utf8>>, [label(X@3)]);

        {select, X@4} ->
            node(<<"g"/utf8>>, [label(X@4)]);

        {overwrite, X@5} ->
            node(<<"o"/utf8>>, [label(X@5)]);

        {tag, X@6} ->
            node(<<"t"/utf8>>, [label(X@6)]);

        {'case', X@7} ->
            node(<<"m"/utf8>>, [label(X@7)]);

        no_cases ->
            node(<<"n"/utf8>>, []);

        {perform, X@8} ->
            node(<<"p"/utf8>>, [label(X@8)]);

        {handle, X@9} ->
            node(<<"h"/utf8>>, [label(X@9)]);

        {builtin, X@10} ->
            node(<<"b"/utf8>>, [label(X@10)]);

        {content_reference, Identifier} ->
            node(<<"#"/utf8>>, [{<<"l"/utf8>>, dag_json:cid(Identifier)}]);

        {release_reference, P, R, I@1} ->
            node(
                <<"@"/utf8>>,
                [{<<"p"/utf8>>, fun gleam@json:string/1(P)},
                    {<<"r"/utf8>>, fun gleam@json:int/1(R)},
                    {<<"l"/utf8>>, dag_json:cid(I@1)}]
            );

        {relative_reference, Identifier@1} ->
            node(
                <<"."/utf8>>,
                [{<<"i"/utf8>>, fun gleam@json:string/1(Identifier@1)}]
            )
    end.

-file("src/eyg/ir/dag_json.gleam", 199).
-spec to_block({eyg@ir@tree:expression(ETZ), ETZ}) -> bitstring().
to_block(Data) ->
    dag_json:encode(to_data_model(Data)).

-file("src/eyg/ir/dag_json.gleam", 203).
-spec to_string({eyg@ir@tree:expression(EUB), EUB}) -> binary().
to_string(Data) ->
    gleam@json:to_string(to_data_model(Data)).