-module(lc_warnings).
-compile([export_all]).

close(Fs) ->
    %% There should be a warning since we ignore a potential
    %% {error,Error} return from file:close/1.
    [file:close(F) || F <- Fs],

    %% No warning because the type of unmatched return will be ['ok']
    %% (which is a list of a simple type).
    [ok = file:close(F) || F <- Fs],

    %% Suppressed.
    _ = [file:close(F) || F <- Fs],
    ok.

format(X) ->
    %% No warning since the result of the list comprehension is
    %% a list of simple.
    [io:format("~p\n", [E]) || E <- X],

    %% Warning explicitly suppressed.
    _ = [io:format("~p\n", [E]) || E <- X],
    ok.

opaque1() ->
    List = gen_atom(),
    %% This is a list of an externally defined opaque type. Since
    %% we are not allowed to peek inside opaque types, there should
    %% be a warning (even though the type in this case happens to be
    %% an atom).
    [E || E <- List],

    %% Suppressed.
    _ = [E || E <- List],
    ok.

opaque2() ->
    List = gen_array(),
    %% This is an list of an externally defined opaque type. Since
    %% we are not allowed to peek inside opaque types, there should
    %% be a warning.
    [E || E <- List],

    %% Suppressed.
    _ = [E || E <- List],
    ok.

opaque3() ->
    List = gen_int(),

    %% No warning, since we are allowed to look into the type and can
    %% see that it is a simple type.
    [E || E <- List],

    %% Suppressed.
    _ = [E || E <- List],
    ok.

opaque4() ->
    List = gen_tuple(),

    %% There should be a warning, since we are allowed to look inside
    %% the opaque type and see that it is a tuple (non-simple).
    [E || E <- List],

    %% Suppressed.
    _ = [E || E <- List],
    ok.

gen_atom() ->
    [opaque_atom_adt:atom(ok)].

gen_array() ->
    [array:new()].


gen_int() ->
    [opaque_int(42)].

gen_tuple() ->
    [opaque_tuple(x, 25)].

-opaque opaque_int() :: integer().

-spec opaque_int(integer()) -> opaque_int().

opaque_int(Int) -> Int.

-opaque opaque_tuple() :: {any(),any()}.

-spec opaque_tuple(any(), any()) -> opaque_tuple().

opaque_tuple(X, Y) ->
    {X,Y}.