graded

-module(graded@internal@signatures).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/graded/internal/signatures.gleam").
-export([empty/0, merge/2, lookup/2, fn_typed_param_names/2, operator_param_names/2, fn_typed_param_names_ordered/2, operator_callback_positions/3, from_glance_module/2, fn_typed_params_from_function/1, operator_params_from_function/1, operator_callback_positions_of_type/1, is_function_return_type/1, load_from_packages_dir/1]).
-export_type([parameter_info/0, signature_registry/0]).

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

?MODULEDOC(false).

-type parameter_info() :: {parameter_info,
        integer(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        boolean(),
        boolean(),
        list(integer())}.

-type signature_registry() :: {signature_registry,
        gleam@dict:dict(graded@internal@types:qualified_name(), list(parameter_info()))}.

-file("src/graded/internal/signatures.gleam", 66).
?DOC(false).
-spec empty() -> signature_registry().
empty() ->
    {signature_registry, maps:new()}.

-file("src/graded/internal/signatures.gleam", 73).
?DOC(false).
-spec merge(signature_registry(), signature_registry()) -> signature_registry().
merge(A, B) ->
    {signature_registry, maps:merge(erlang:element(2, A), erlang:element(2, B))}.

-file("src/graded/internal/signatures.gleam", 78).
?DOC(false).
-spec lookup(signature_registry(), graded@internal@types:qualified_name()) -> gleam@option:option(list(parameter_info())).
lookup(Registry, Name) ->
    case gleam_stdlib:map_get(erlang:element(2, Registry), Name) of
        {ok, Params} ->
            {some, Params};

        {error, nil} ->
            none
    end.

-file("src/graded/internal/signatures.gleam", 93).
?DOC(false).
-spec fn_typed_param_names(
    signature_registry(),
    graded@internal@types:qualified_name()
) -> gleam@set:set(binary()).
fn_typed_param_names(Registry, Name) ->
    case lookup(Registry, Name) of
        none ->
            gleam@set:new();

        {some, Params} ->
            _pipe = Params,
            _pipe@1 = gleam@list:filter(
                _pipe,
                fun(P) -> erlang:element(5, P) end
            ),
            _pipe@2 = gleam@list:filter_map(
                _pipe@1,
                fun(P@1) ->
                    gleam@option:to_result(
                        gleam@option:'or'(
                            erlang:element(3, P@1),
                            erlang:element(4, P@1)
                        ),
                        nil
                    )
                end
            ),
            gleam@set:from_list(_pipe@2)
    end.

-file("src/graded/internal/signatures.gleam", 111).
?DOC(false).
-spec operator_param_names(
    signature_registry(),
    graded@internal@types:qualified_name()
) -> gleam@set:set(binary()).
operator_param_names(Registry, Name) ->
    case lookup(Registry, Name) of
        none ->
            gleam@set:new();

        {some, Params} ->
            _pipe = Params,
            _pipe@1 = gleam@list:filter(
                _pipe,
                fun(P) -> erlang:element(6, P) end
            ),
            _pipe@2 = gleam@list:filter_map(
                _pipe@1,
                fun(P@1) ->
                    gleam@option:to_result(
                        gleam@option:'or'(
                            erlang:element(3, P@1),
                            erlang:element(4, P@1)
                        ),
                        nil
                    )
                end
            ),
            gleam@set:from_list(_pipe@2)
    end.

-file("src/graded/internal/signatures.gleam", 132).
?DOC(false).
-spec fn_typed_param_names_ordered(
    signature_registry(),
    graded@internal@types:qualified_name()
) -> list(binary()).
fn_typed_param_names_ordered(Registry, Name) ->
    case lookup(Registry, Name) of
        none ->
            [];

        {some, Params} ->
            _pipe = Params,
            _pipe@1 = gleam@list:filter(
                _pipe,
                fun(P) -> erlang:element(5, P) end
            ),
            _pipe@2 = gleam@list:sort(
                _pipe@1,
                fun(A, B) ->
                    gleam@int:compare(
                        erlang:element(2, A),
                        erlang:element(2, B)
                    )
                end
            ),
            gleam@list:filter_map(
                _pipe@2,
                fun(P@1) ->
                    gleam@option:to_result(
                        gleam@option:'or'(
                            erlang:element(3, P@1),
                            erlang:element(4, P@1)
                        ),
                        nil
                    )
                end
            )
    end.

-file("src/graded/internal/signatures.gleam", 154).
?DOC(false).
-spec operator_callback_positions(
    signature_registry(),
    graded@internal@types:qualified_name(),
    binary()
) -> list(integer()).
operator_callback_positions(Registry, Callee_name, Param_name) ->
    case lookup(Registry, Callee_name) of
        none ->
            [];

        {some, Params} ->
            _pipe = Params,
            _pipe@1 = gleam@list:find(
                _pipe,
                fun(P) ->
                    gleam@option:'or'(
                        erlang:element(3, P),
                        erlang:element(4, P)
                    )
                    =:= {some, Param_name}
                end
            ),
            _pipe@2 = gleam@result:map(
                _pipe@1,
                fun(P@1) -> erlang:element(7, P@1) end
            ),
            gleam@result:unwrap(_pipe@2, [])
    end.

-file("src/graded/internal/signatures.gleam", 296).
?DOC(false).
-spec assignment_name(glance:assignment_name()) -> gleam@option:option(binary()).
assignment_name(Name) ->
    case Name of
        {named, N} ->
            {some, N};

        {discarded, _} ->
            none
    end.

-file("src/graded/internal/signatures.gleam", 289).
?DOC(false).
-spec is_function_type(glance:type()) -> boolean().
is_function_type(T) ->
    case T of
        {function_type, _, _, _} ->
            true;

        _ ->
            false
    end.

-file("src/graded/internal/signatures.gleam", 282).
?DOC(false).
-spec all_function_indices(list(glance:type())) -> list(integer()).
all_function_indices(Types) ->
    _pipe = Types,
    _pipe@1 = gleam@list:index_map(
        _pipe,
        fun(T, I) -> {I, is_function_type(T)} end
    ),
    _pipe@2 = gleam@list:filter(
        _pipe@1,
        fun(Pair) -> erlang:element(2, Pair) end
    ),
    gleam@list:map(_pipe@2, fun(Pair@1) -> erlang:element(1, Pair@1) end).

-file("src/graded/internal/signatures.gleam", 175).
?DOC(false).
-spec from_glance_module(binary(), glance:module_()) -> signature_registry().
from_glance_module(Module_path, Module) ->
    Signatures = gleam@list:fold(
        erlang:element(6, Module),
        maps:new(),
        fun(Acc, Definition) ->
            Function = erlang:element(3, Definition),
            Params = gleam@list:index_map(
                erlang:element(5, Function),
                fun(Param, I) ->
                    Callback_positions = case erlang:element(4, Param) of
                        {some, {function_type, _, Param_types, _}} ->
                            all_function_indices(Param_types);

                        _ ->
                            []
                    end,
                    {parameter_info,
                        I,
                        erlang:element(2, Param),
                        assignment_name(erlang:element(3, Param)),
                        case erlang:element(4, Param) of
                            {some, {function_type, _, _, _}} ->
                                true;

                            _ ->
                                false
                        end,
                        Callback_positions /= [],
                        Callback_positions}
                end
            ),
            gleam@dict:insert(
                Acc,
                {qualified_name, Module_path, erlang:element(3, Function)},
                Params
            )
        end
    ),
    {signature_registry, Signatures}.

-file("src/graded/internal/signatures.gleam", 218).
?DOC(false).
-spec fn_typed_params_from_function(glance:function_()) -> gleam@set:set(binary()).
fn_typed_params_from_function(Function) ->
    _pipe = erlang:element(5, Function),
    _pipe@1 = gleam@list:filter_map(
        _pipe,
        fun(Param) -> case erlang:element(4, Param) of
                {some, {function_type, _, _, _}} ->
                    case assignment_name(erlang:element(3, Param)) of
                        {some, Name} ->
                            {ok, Name};

                        none ->
                            {error, nil}
                    end;

                _ ->
                    {error, nil}
            end end
    ),
    gleam@set:from_list(_pipe@1).

-file("src/graded/internal/signatures.gleam", 243).
?DOC(false).
-spec operator_params_from_function(glance:function_()) -> gleam@dict:dict(binary(), list(integer())).
operator_params_from_function(Function) ->
    _pipe = erlang:element(5, Function),
    _pipe@1 = gleam@list:filter_map(
        _pipe,
        fun(Param) ->
            case {erlang:element(4, Param),
                assignment_name(erlang:element(3, Param))} of
                {{some, {function_type, _, Param_types, _}}, {some, Name}} ->
                    case all_function_indices(Param_types) of
                        [] ->
                            {error, nil};

                        Positions ->
                            {ok, {Name, Positions}}
                    end;

                {_, _} ->
                    {error, nil}
            end
        end
    ),
    maps:from_list(_pipe@1).

-file("src/graded/internal/signatures.gleam", 264).
?DOC(false).
-spec operator_callback_positions_of_type(glance:type()) -> list(integer()).
operator_callback_positions_of_type(Type_) ->
    case Type_ of
        {function_type, _, Param_types, _} ->
            all_function_indices(Param_types);

        _ ->
            []
    end.

-file("src/graded/internal/signatures.gleam", 276).
?DOC(false).
-spec is_function_return_type(glance:type()) -> boolean().
is_function_return_type(Type_) ->
    is_function_type(Type_).

-file("src/graded/internal/signatures.gleam", 355).
?DOC(false).
-spec bool_or_default({ok, SEQ} | {error, any()}, SEU, fun((SEQ) -> SEU)) -> SEU.
bool_or_default(Result, Default, Next) ->
    case Result of
        {ok, V} ->
            Next(V);

        {error, _} ->
            Default
    end.

-file("src/graded/internal/signatures.gleam", 340).
?DOC(false).
-spec registry_from_gleam_file(binary(), binary()) -> signature_registry().
registry_from_gleam_file(Gleam_path, Source_dir) ->
    bool_or_default(
        simplifile:read(Gleam_path),
        empty(),
        fun(Source) ->
            bool_or_default(
                glance:module(Source),
                empty(),
                fun(Module) ->
                    from_glance_module(
                        graded@internal@config:module_path_for_source(
                            Gleam_path,
                            Source_dir
                        ),
                        Module
                    )
                end
            )
        end
    ).

-file("src/graded/internal/signatures.gleam", 328).
?DOC(false).
-spec registry_from_source_dir(binary()) -> signature_registry().
registry_from_source_dir(Source_dir) ->
    case simplifile:get_files(Source_dir) of
        {error, _} ->
            empty();

        {ok, Files} ->
            _pipe = Files,
            _pipe@1 = gleam@list:filter(
                _pipe,
                fun(P) ->
                    gleam_stdlib:string_ends_with(P, <<".gleam"/utf8>>)
                end
            ),
            gleam@list:fold(
                _pipe@1,
                empty(),
                fun(Acc, Gleam_path) ->
                    merge(Acc, registry_from_gleam_file(Gleam_path, Source_dir))
                end
            )
    end.

-file("src/graded/internal/signatures.gleam", 317).
?DOC(false).
-spec load_from_packages_dir(binary()) -> signature_registry().
load_from_packages_dir(Packages_dir) ->
    case simplifile_erl:read_directory(Packages_dir) of
        {error, _} ->
            empty();

        {ok, Entries} ->
            gleam@list:fold(
                Entries,
                empty(),
                fun(Acc, Dep) ->
                    Src_dir = filepath:join(
                        filepath:join(Packages_dir, Dep),
                        <<"src"/utf8>>
                    ),
                    merge(Acc, registry_from_source_dir(Src_dir))
                end
            )
    end.