eyg_parser

-module(eyg@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/eyg/parser.gleam").
-export([from_string/1, all_from_string/1, block_from_string/1, format_error/2]).

-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/parser.gleam", 10).
-spec from_string(binary()) -> {ok,
        {{eyg@ir@tree:expression({integer(), integer()}),
                {integer(), integer()}},
            list({eyg@parser@token:token(), integer()})}} |
    {error, eyg@parser@parser:reason()}.
from_string(Src) ->
    _pipe = Src,
    _pipe@1 = eyg@parser@lexer:lex(_pipe),
    _pipe@2 = eyg@parser@token:drop_whitespace(_pipe@1),
    _pipe@3 = eyg@parser@token:drop_comments(_pipe@2),
    eyg@parser@parser:expression(_pipe@3).

-file("src/eyg/parser.gleam", 18).
-spec all_from_string(binary()) -> {ok,
        {eyg@ir@tree:expression({integer(), integer()}), {integer(), integer()}}} |
    {error, eyg@parser@parser:reason()}.
all_from_string(Src) ->
    gleam@result:'try'(
        from_string(Src),
        fun(_use0) ->
            {Source, Remaining} = _use0,
            case Remaining of
                [] ->
                    {ok, Source};

                [{Tok, At} | _] ->
                    {error, {trailing_tokens, Tok, At}}
            end
        end
    ).

-file("src/eyg/parser.gleam", 39).
-spec do_gather(
    {eyg@ir@tree:expression(GFY), GFY},
    list({binary(), {eyg@ir@tree:expression(GFY), GFY}, GFY})
) -> {list({binary(), {eyg@ir@tree:expression(GFY), GFY}, GFY}),
    gleam@option:option({eyg@ir@tree:expression(GFY), GFY})}.
do_gather(Exp, Acc) ->
    {Exp@1, Span} = Exp,
    case Exp@1 of
        {'let', Label, Value, Then} ->
            do_gather(Then, [{Label, Value, Span} | Acc]);

        vacant ->
            {Acc, none};

        _ ->
            {Acc, {some, {Exp@1, Span}}}
    end.

-file("src/eyg/parser.gleam", 26).
-spec block_from_string(binary()) -> {ok,
        {{list({binary(),
                    {eyg@ir@tree:expression({integer(), integer()}),
                        {integer(), integer()}},
                    {integer(), integer()}}),
                gleam@option:option({eyg@ir@tree:expression({integer(),
                        integer()}),
                    {integer(), integer()}})},
            list({eyg@parser@token:token(), integer()})}} |
    {error, eyg@parser@parser:reason()}.
block_from_string(Src) ->
    Parsed = begin
        _pipe = Src,
        _pipe@1 = eyg@parser@lexer:lex(_pipe),
        _pipe@2 = eyg@parser@token:drop_whitespace(_pipe@1),
        _pipe@3 = eyg@parser@token:drop_comments(_pipe@2),
        eyg@parser@parser:block(_pipe@3)
    end,
    case Parsed of
        {ok, {Exp, Left}} ->
            {ok, {do_gather(Exp, []), Left}};

        {error, Reason} ->
            {error, Reason}
    end.

-file("src/eyg/parser.gleam", 60).
-spec reason_position(eyg@parser@parser:reason()) -> gleam@option:option(integer()).
reason_position(Reason) ->
    case Reason of
        {unexpected_token, _, Pos} ->
            {some, Pos};

        unexpect_end ->
            none;

        {missing_equals, Pos@1} ->
            {some, Pos@1};

        {missing_arrow, Pos@2} ->
            {some, Pos@2};

        {unclosed_function_body, Open_at} ->
            {some, Open_at};

        {expected_effect_name, _, Pos@3} ->
            {some, Pos@3};

        {expected_builtin_name, Pos@4} ->
            {some, Pos@4};

        {invalid_cid_reference, Pos@5} ->
            {some, Pos@5};

        {invalid_import_path, Pos@6} ->
            {some, Pos@6};

        {trailing_tokens, _, Pos@7} ->
            {some, Pos@7};

        {invalid_character, _, Pos@8} ->
            {some, Pos@8};

        {unterminated_string_literal, Pos@9} ->
            {some, Pos@9};

        {invalid_escape_sequence, _, Pos@10} ->
            {some, Pos@10}
    end.

-file("src/eyg/parser.gleam", 83).
-spec do_source_context(list(binary()), integer(), integer(), integer()) -> binary().
do_source_context(Lines, Target, Line_num, Offset) ->
    case Lines of
        [] ->
            <<""/utf8>>;

        [Line | Rest] ->
            Line_len = erlang:byte_size(Line),
            Line_end = Offset + Line_len,
            case Target =< Line_end of
                true ->
                    Col = gleam@int:max(0, Target - Offset),
                    Num_str = erlang:integer_to_binary(Line_num),
                    Gutter = <<<<" "/utf8, Num_str/binary>>/binary, " | "/utf8>>,
                    Blank_gutter = gleam@string:repeat(
                        <<" "/utf8>>,
                        string:length(Gutter)
                    ),
                    <<<<<<<<<<Gutter/binary, Line/binary>>/binary, "\n"/utf8>>/binary,
                                Blank_gutter/binary>>/binary,
                            (gleam@string:repeat(<<" "/utf8>>, Col))/binary>>/binary,
                        "^"/utf8>>;

                false ->
                    do_source_context(Rest, Target, Line_num + 1, Line_end + 1)
            end
    end.

-file("src/eyg/parser.gleam", 78).
-spec source_context(binary(), integer()) -> binary().
source_context(Source, Pos) ->
    Lines = gleam@string:split(Source, <<"\n"/utf8>>),
    do_source_context(Lines, Pos, 1, 0).

-file("src/eyg/parser.gleam", 51).
?DOC(
    " Format a parse error as a human-readable string, showing the relevant\n"
    " source line with a pointer to the error location.\n"
).
-spec format_error(eyg@parser@parser:reason(), binary()) -> binary().
format_error(Reason, Source) ->
    Description = eyg@parser@parser:describe_reason(Reason),
    case reason_position(Reason) of
        none ->
            <<"error: "/utf8, Description/binary>>;

        {some, Pos} ->
            <<<<<<"error: "/utf8, Description/binary>>/binary, "\n\n"/utf8>>/binary,
                (source_context(Source, Pos))/binary>>
    end.