cleam

-module(internal@ast_fun).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([is_pub_fun_used/3, public_funs/1]).
-export_type([public_fun/0, module_name/0, imported_info/0]).

-type public_fun() :: {public_fun, binary()}.

-type module_name() :: {module_name, binary()}.

-type imported_info() :: {module_imported, module_name()} |
    function_imported_as_alias.

-spec check_fun_usage(list(any()), public_fun(), module_name()) -> {ok, nil} |
    {error, nil}.
check_fun_usage(Statements, Pub_fun_name, Module_name) ->
    {public_fun, Pub_fun_name@1} = case Pub_fun_name of
        {public_fun, _} -> Pub_fun_name;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"internal/ast_fun"/utf8>>,
                        function => <<"check_fun_usage"/utf8>>,
                        line => 62})
    end,
    {module_name, Module_name@1} = case Module_name of
        {module_name, _} -> Module_name;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@1,
                        module => <<"internal/ast_fun"/utf8>>,
                        function => <<"check_fun_usage"/utf8>>,
                        line => 63})
    end,
    gleam@list:find_map(
        Statements,
        fun(Statement) ->
            case begin
                _pipe = Statement,
                _pipe@1 = gleam@string:inspect(_pipe),
                gleam_stdlib:contains_string(
                    _pipe@1,
                    <<<<<<<<"FieldAccess(Variable(\""/utf8,
                                    Module_name@1/binary>>/binary,
                                "\"), \""/utf8>>/binary,
                            Pub_fun_name@1/binary>>/binary,
                        "\")"/utf8>>
                )
            end of
                true ->
                    {ok, nil};

                false ->
                    {error, nil}
            end
        end
    ).

-spec module_full_name_to_module_name(internal@fs:module_full_name()) -> module_name().
module_full_name_to_module_name(Module_full_name) ->
    {module_full_name, Module_full_name@1} = case Module_full_name of
        {module_full_name, _} -> Module_full_name;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"internal/ast_fun"/utf8>>,
                        function => <<"module_full_name_to_module_name"/utf8>>,
                        line => 82})
    end,
    _assert_subject = begin
        _pipe = gleam@string:split(Module_full_name@1, <<"/"/utf8>>),
        gleam@list:last(_pipe)
    end,
    {ok, Module_name} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@1,
                        module => <<"internal/ast_fun"/utf8>>,
                        function => <<"module_full_name_to_module_name"/utf8>>,
                        line => 83})
    end,
    {module_name, Module_name}.

-spec function_imported_info(
    list(glance:definition(glance:import())),
    internal@fs:module_full_name(),
    public_fun()
) -> list(imported_info()).
function_imported_info(Imports, Module_full_name, Pub_fun_name) ->
    gleam@list:filter_map(Imports, fun(Imp) -> case Imp of
                {definition, _, {import, Import_name, Module_alias, _, Aliases}} when {module_full_name,
                    Import_name} =:= Module_full_name ->
                    case gleam@list:any(
                        Aliases,
                        fun(Alias) ->
                            {unqualified_import, Fun_name, _} = case Alias of
                                {unqualified_import, _, _} -> Alias;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                value => _assert_fail,
                                                module => <<"internal/ast_fun"/utf8>>,
                                                function => <<"function_imported_info"/utf8>>,
                                                line => 97})
                            end,
                            {public_fun, Fun_name} =:= Pub_fun_name
                        end
                    ) of
                        true ->
                            {ok, function_imported_as_alias};

                        false ->
                            {ok, {module_imported, case Module_alias of
                                        {some, Alias@1} ->
                                            {module_name, Alias@1};

                                        none ->
                                            module_full_name_to_module_name(
                                                Module_full_name
                                            )
                                    end}}
                    end;

                _ ->
                    {error, nil}
            end end).

-spec is_pub_fun_used(
    internal@ast:another_files_ast(),
    public_fun(),
    internal@fs:module_full_name()
) -> boolean().
is_pub_fun_used(Files_ast, Pub_fun_name, Module_full_name) ->
    Is_used_somewhere = begin
        {another_files_ast, Files_ast@1} = case Files_ast of
            {another_files_ast, _} -> Files_ast;
            _assert_fail ->
                erlang:error(#{gleam_error => let_assert,
                            message => <<"Assertion pattern match failed"/utf8>>,
                            value => _assert_fail,
                            module => <<"internal/ast_fun"/utf8>>,
                            function => <<"is_pub_fun_used"/utf8>>,
                            line => 39})
        end,
        gleam@list:find_map(
            Files_ast@1,
            fun(File_ast) ->
                {file_ast, Ast} = case File_ast of
                    {file_ast, _} -> File_ast;
                    _assert_fail@1 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Assertion pattern match failed"/utf8>>,
                                    value => _assert_fail@1,
                                    module => <<"internal/ast_fun"/utf8>>,
                                    function => <<"is_pub_fun_used"/utf8>>,
                                    line => 41})
                end,
                {module, Imports, _, _, _, _, _, Fns} = case Ast of
                    {module, _, _, _, _, _, _, _} -> Ast;
                    _assert_fail@2 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Assertion pattern match failed"/utf8>>,
                                    value => _assert_fail@2,
                                    module => <<"internal/ast_fun"/utf8>>,
                                    function => <<"is_pub_fun_used"/utf8>>,
                                    line => 42})
                end,
                Imported_info_list = function_imported_info(
                    Imports,
                    Module_full_name,
                    Pub_fun_name
                ),
                gleam@list:find_map(
                    Imported_info_list,
                    fun(Imported_info) -> case Imported_info of
                            function_imported_as_alias ->
                                {ok, nil};

                            {module_imported, Module_name} ->
                                gleam@list:find_map(
                                    Fns,
                                    fun(Fun_def) ->
                                        {definition,
                                            _,
                                            {function,
                                                _,
                                                _,
                                                _,
                                                _,
                                                Statements,
                                                _}} = case Fun_def of
                                            {definition,
                                                _,
                                                {function, _, _, _, _, _, _}} -> Fun_def;
                                            _assert_fail@3 ->
                                                erlang:error(
                                                        #{gleam_error => let_assert,
                                                            message => <<"Assertion pattern match failed"/utf8>>,
                                                            value => _assert_fail@3,
                                                            module => <<"internal/ast_fun"/utf8>>,
                                                            function => <<"is_pub_fun_used"/utf8>>,
                                                            line => 50}
                                                    )
                                        end,
                                        check_fun_usage(
                                            Statements,
                                            Pub_fun_name,
                                            Module_name
                                        )
                                    end
                                )
                        end end
                )
            end
        )
    end,
    case Is_used_somewhere of
        {ok, nil} ->
            true;

        {error, nil} ->
            false
    end.

-spec public_funs(internal@ast:file_ast()) -> list(public_fun()).
public_funs(File_ast) ->
    {file_ast, Ast} = case File_ast of
        {file_ast, _} -> File_ast;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"internal/ast_fun"/utf8>>,
                        function => <<"public_funs"/utf8>>,
                        line => 27})
    end,
    {module, _, _, _, _, _, _, Funs} = case Ast of
        {module, _, _, _, _, _, _, _} -> Ast;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@1,
                        module => <<"internal/ast_fun"/utf8>>,
                        function => <<"public_funs"/utf8>>,
                        line => 28})
    end,
    gleam@list:flat_map(
        Funs,
        fun(Fun_def) ->
            {definition, _, {function, Fun_name, Is_public, _, _, _, _}} = case Fun_def of
                {definition, _, {function, _, _, _, _, _, _}} -> Fun_def;
                _assert_fail@2 ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Assertion pattern match failed"/utf8>>,
                                value => _assert_fail@2,
                                module => <<"internal/ast_fun"/utf8>>,
                                function => <<"public_funs"/utf8>>,
                                line => 30})
            end,
            case Is_public of
                public when Fun_name =/= <<"main"/utf8>> ->
                    [{public_fun, Fun_name}];

                _ ->
                    []
            end
        end
    ).