Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Type issue with argument error prong causing unmatched case branch #502

Open
harrisi opened this issue Dec 31, 2024 · 0 comments
Open

Type issue with argument error prong causing unmatched case branch #502

harrisi opened this issue Dec 31, 2024 · 0 comments

Comments

@harrisi
Copy link

harrisi commented Dec 31, 2024

I'm mostly sharing this because it's such a complex type that Elixir has worked out, which is interesting. I'm not sure how to best parse this to try to identify where the issue is coming from. There's another one for lib/zig/nif/_basic.ex:121: Zig.Nif.Basic.render_elixir_marshalled/1, but it's too long to post both. :)

long warnings
    warning: the following clause will never match:

        {[], []}

    because it attempts to match on the result of:

        {argument_error_prong, error_return_prong}

    which has type:

        dynamic(
          {non_empty_list(
             {:->, empty_list(),
              non_empty_list(
                non_empty_list(
                  :error or
                    {:{}, empty_list(),
                     non_empty_list(
                       :argument_error or {:error_lines or :index, empty_list(), Zig.ErrorProng}
                     )}
                ) or
                  {:__block__, empty_list(),
                   non_empty_list(
                     {:=, empty_list(),
                      non_empty_list(
                        {:case, empty_list(),
                         non_empty_list(
                           non_empty_list(
                             {:do,
                              non_empty_list(
                                {:->, empty_list(),
                                 non_empty_list(
                                   non_empty_list(
                                     non_empty_list(
                                       {:{}, empty_list(),
                                        non_empty_list(
                                          {:_ or :_f or :_m or :a, empty_list(), Zig.ErrorProng}
                                        )} or
                                         {:|, empty_list(),
                                          non_empty_list(
                                            {:rest, empty_list(), Zig.ErrorProng} or
                                              {:{}, empty_list(),
                                               non_empty_list(
                                                 {:_a or :f or :m or :opts, empty_list(), Zig.ErrorProng}
                                               )}
                                          )}
                                     )
                                   ) or
                                     {:__block__, empty_list(),
                                      non_empty_list(
                                        non_empty_list(
                                          {:|, empty_list(),
                                           non_empty_list(
                                             {:rest, empty_list(), Zig.ErrorProng} or
                                               {:{}, empty_list(),
                                                non_empty_list(
                                                  {:a or :f or :m or :new_opts, empty_list(),
                                                   Zig.ErrorProng}
                                                )}
                                           )}
                                        ) or
                                          {:=, empty_list(),
                                           non_empty_list(
                                             {:&, empty_list(),
                                              non_empty_list(
                                                non_empty_list(
                                                  binary() or
                                                    {{:., empty_list(),
                                                      non_empty_list(
                                                        :duplicate or
                                                          {:__aliases__, non_empty_list({:alias, false}),
                                                           non_empty_list(:List)}
                                                      )}, empty_list(),
                                                     non_empty_list(
                                                       binary() or
                                                         {:&, empty_list(), non_empty_list(integer())}
                                                     )}
                                                )
                                              )} or {:indentation, empty_list(), Zig.ErrorProng}
                                           ) or
                                             non_empty_list(
                                               {:new_opts, empty_list(), Zig.ErrorProng} or
                                                 {{:., empty_list(),
                                                   non_empty_list(
                                                     :merge or
                                                       {:__aliases__, non_empty_list({:alias, false}),
                                                        non_empty_list(:Keyword)}
                                                   )}, empty_list(),
                                                  non_empty_list(
                                                    non_empty_list(
                                                      {:error_info,
                                                       {:%{}, empty_list(),
                                                        non_empty_list(
                                                          {:function, :_format_error} or
                                                            {:module,
                                                             {:__MODULE__, empty_list(), Zig.ErrorProng}}
                                                        )}} or
                                                        {:zigler_error,
                                                         {:%{}, empty_list(),
                                                          non_empty_list(
                                                            {{:+,
                                                              non_empty_list(
                                                                {:context, Zig.ErrorProng} or
                                                                  {:imports,
                                                                   non_empty_list({integer(), Kernel})}
                                                              ),
                                                              non_empty_list(
                                                                integer() or
                                                                  {:index, empty_list(), Zig.ErrorProng}
                                                              )},
                                                             {:|>,
                                                              non_empty_list(
                                                                {:context, Zig.ErrorProng} or
                                                                  {:imports,
                                                                   non_empty_list({integer(), Kernel})}
                                                              ),
                                                              non_empty_list(
                                                                {:|>,
                                                                 non_empty_list(
                                                                   {:context, Zig.ErrorProng} or
                                                                     {:imports,
                                                                      non_empty_list({integer(), Kernel})}
                                                                 ),
                                                                 non_empty_list(
                                                                   {:|>,
                                                                    non_empty_list(
                                                                      {:context, Zig.ErrorProng} or
                                                                        {:imports,
                                                                         non_empty_list(
                                                                           {integer(), Kernel}
                                                                         )}
                                                                    ),
                                                                    non_empty_list(
                                                                      {:|>,
                                                                       non_empty_list(
                                                                         {:context, Zig.ErrorProng} or
                                                                           {:imports,
                                                                            non_empty_list(
                                                                              {integer(), Kernel}
                                                                            )}
                                                                       ),
                                                                       non_empty_list(
                                                                         {:elem,
                                                                          non_empty_list(
                                                                            {:context, Zig.ErrorProng} or
                                                                              {:imports,
                                                                               non_empty_list(
                                                                                 {integer(), Kernel}
                                                                               )}
                                                                          ),
                                                                          non_empty_list(integer())} or
                                                                           {:|>,
                                                                            non_empty_list(
                                                                              {:context, Zig.ErrorProng} or
                                                                                {:imports,
                                                                                 non_empty_list(
                                                                                   {integer(), Kernel}
                                                                                 )}
                                                                            ),
                                                                            non_empty_list(
                                                                              {:error_lines, empty_list(),
                                                                               Zig.ErrorProng} or
                                                                                {{:., empty_list(),
                                                                                  non_empty_list(
                                                                                    :reduce or
                                                                                      {:__aliases__,
                                                                                       non_empty_list(
                                                                                         {:alias, false}
                                                                                       ),
                                                                                       non_empty_list(
                                                                                         :Enum
                                                                                       )}
                                                                                  )}, empty_list(),
                                                                                 non_empty_list(
                                                                                   {:fn, empty_list(),
                                                                                    non_empty_list(
                                                                                      {:->, empty_list(),
                                                                                       non_empty_list(
                                                                                         non_empty_list(
                                                                                           :enter or
                                                                                             {{:so_far,
                                                                                               empty_list(),
                                                                                               Zig.ErrorProng},
                                                                                              {:indents,
                                                                                               empty_list(),
                                                                                               Zig.ErrorProng}}
                                                                                         ) or
                                                                                           {{:so_far,
                                                                                             empty_list(),
                                                                                             Zig.ErrorProng},
                                                                                            {:+,
                                                                                             non_empty_list(
                                                                                               {:context,
                                                                                                Zig.ErrorProng} or
                                                                                                 {:imports,
                                                                                                  non_empty_list(
                                                                                                    {integer(),
                                                                                                     Kernel}
                                                                                                  )}
                                                                                             ),
                                                                                             non_empty_list(
                                                                                               integer() or
                                                                                                 {:indents,
                                                                                                  empty_list(),
                                                                                                  Zig.ErrorProng}
                                                                                             )}}
                                                                                       ) or
                                                                                         non_empty_list(
                                                                                           non_empty_list(
                                                                                             {:error_line,
                                                                                              empty_list(),
                                                                                              Zig.ErrorProng} or
                                                                                               {{:so_far,
                                                                                                 empty_list(),
                                                                                                 Zig.ErrorProng},
                                                                                                {:indents,
                                                                                                 empty_list(),
                                                                                                 Zig.ErrorProng}}
                                                                                           ) or
                                                                                             {:__block__,
                                                                                              empty_list(),
                                                                                              non_empty_list(
                                                                                                {:=,
                                                                                                 empty_list(),
                                                                                                 non_empty_list(
                                                                                                   {:error_msg,
                                                                                                    empty_list(),
                                                                                                    Zig.ErrorProng} or
                                                                                                     {:|>,
                                                                                                      non_empty_list(
                                                                                                        {:context,
                                                                                                         Zig.ErrorProng} or
                                                                                                          {:imports,
                                                                                                           non_empty_list(
                                                                                                             {integer(),
                                                                                                              Kernel}
                                                                                                           )}
                                                                                                      ),
                                                                                                      non_empty_list(
                                                                                                        {:|>,
                                                                                                         non_empty_list(
                                                                                                           {:context,
                                                                                                            Zig.ErrorProng} or
                                                                                                             {:imports,
                                                                                                              non_empty_list(
                                                                                                                {integer(),
                                                                                                                 Kernel}
                                                                                                              )}
                                                                                                         ),
                                                                                                         non_empty_list(
                                                                                                           {:|>,
                                                                                                            non_empty_list(
                                                                                                              {:context,
                                                                                                               Zig.ErrorProng} or
                                                                                                                {:imports,
                                                                                                                 non_empty_list(
                                                                                                                   {integer(),
                                                                                                                    Kernel}
                                                                                                                 )}
                                                                                                            ),
                                                                                                            non_empty_list(
                                                                                                              {:|>,
                                                                                                               non_empty_list(
                                                                                                                 {:context,
                                                                                                                  Zig.ErrorProng} or
                                                                                                                   {:imports,
                                                                                                                    non_empty_list(
                                                                                                                      {integer(),
                                                                                                                       Kernel}
                                                                                                                    )}
                                                                                                               ),
                                                                                                               non_empty_list(
                                                                                                                 {:error_line,
                                                                                                                  empty_list(),
                                                                                                                  Zig.ErrorProng} or
                                                                                                                   {{:.,
                                                                                                                     empty_list(),
                                                                                                                     non_empty_list(
                                                                                                                       :to_list or
                                                                                                                         {:__aliases__,
                                                                                                                          non_empty_list(
                                                                                                                            {:alias,
                                                                                                                             false}
                                                                                                                          ),
                                                                                                                          non_empty_list(
                                                                                                                            :Tuple
                                                                                                                          )}
                                                                                                                     )},
                                                                                                                    empty_list(),
                                                                                                                    empty_list()}
                                                                                                               )} or
                                                                                                                {{:.,
                                                                                                                  empty_list(),
                                                                                                                  non_empty_list(
                                                                                                                    :map or
                                                                                                                      {:__aliases__,
                                                                                                                       non_empty_list(
                                                                                                                         {:alias,
                                                                                                                          false}
                                                                                                                       ),
                                                                                                                       non_empty_list(
                                                                                                                         :Enum
                                                                                                                       )}
                                                                                                                  )},
                                                                                                                 empty_list(),
                                                                                                                 non_empty_list(
                                                                                                                   {:fn,
                                                                                                                    empty_list(),
                                                                                                                    non_empty_list(
                                                                                                                      {:->,
                                                                                                                       empty_list(),
                                                                                                                       non_empty_list(
                                                                                                                         non_empty_list(
                                                                                                                           {:inspect,
                                                                                                                            {:content,
                                                                                                                             empty_list(),
                                                                                                                             Zig.ErrorProng}}
                                                                                                                         ) or
                                                                                                                           {:<<>>,
                                                                                                                            empty_list(),
                                                                                                                            non_empty_list(
                                                                                                                              {:"::",
                                                                                                                               empty_list(),
                                                                                                                               non_empty_list(
                                                                                                                                 {:binary,
                                                                                                                                  empty_list(),
                                                                                                                                  Zig.ErrorProng} or
                                                                                                                                   {{:.,
                                                                                                                                     empty_list(),
                                                                                                                                     non_empty_list(
                                                                                                                                       Kernel or
                                                                                                                                         :to_string
                                                                                                                                     )},
                                                                                                                                    non_empty_list(
                                                                                                                                      {:from_interpolation,
                                                                                                                                       true}
                                                                                                                                    ),
                                                                                                                                    non_empty_list(
                                                                                                                                      {:inspect,
                                                                                                                                       non_empty_list(
                                                                                                                                         {:context,
                                                                                                                                          Zig.ErrorProng} or
                                                                                                                                           {:imports,
                                                                                                                                            non_empty_list(
                                                                                                                                              {integer(),
                                                                                                                                               Kernel}
                                                                                                                                            )}
                                                                                                                                       ),
                                                                                                                                       non_empty_list(
                                                                                                                                         non_empty_list(
                                                                                                                                           {:custom_options,
                                                                                                                                            non_empty_list(
                                                                                                                                              {:sort_maps,
                                                                                                                                               true}
                                                                                                                                            )}
                                                                                                                                         ) or
                                                                                                                                           {:content,
                                                                                                                                            empty_list(),
                                                                                                                                            Zig.ErrorProng}
                                                                                                                                       )}
                                                                                                                                    )}
                                                                                                                               )}
                                                                                                                            )}
                                                                                                                       ) or
                                                                                                                         non_empty_list(
                                                                                                                           non_empty_list(
                                                                                                                             {:typename,
                                                                                                                              {:typename,
                                                                                                                               empty_list(),
                                                                                                                               Zig.ErrorProng}}
                                                                                                                           ) or
                                                                                                                             {{:.,
                                                                                                                               empty_list(),
                                                                                                                               non_empty_list(
                                                                                                                                 :replace or
                                                                                                                                   {:__aliases__,
                                                                                                                                    non_empty_list(
                                                                                                                                      {:alias,
                                                                                                                                       false}
                                                                                                                                    ),
                                                                                                                                    non_empty_list(
                                                                                                                                      :String
                                                                                                                                    )}
                                                                                                                               )},
                                                                                                                              empty_list(),
                                                                                                                              non_empty_list(
                                                                                                                                binary() or
                                                                                                                                  {:<<>>,
                                                                                                                                   empty_list(),
                                                                                                                                   non_empty_list(
                                                                                                                                     binary() or
                                                                                                                                       {:"::",
                                                                                                                                        empty_list(),
                                                                                                                                        non_empty_list(
                                                                                                                                          {:binary,
                                                                                                                                           empty_list(),
                                                                                                                                           Zig.ErrorProng} or
                                                                                                                                            {{:.,
                                                                                                                                              empty_list(),
                                                                                                                                              non_empty_list(
                                                                                                                                                Kernel or
                                                                                                                                                  :to_string
                                                                                                                                              )},
                                                                                                                                             non_empty_list(
                                                                                                                                               {:from_interpolation,
                                                                                                                                                true}
                                                                                                                                             ),
                                                                                                                                             non_empty_list(
                                                                                                                                               {:__MODULE__,
                                                                                                                                                empty_list(),
                                                                                                                                                Zig.ErrorProng}
                                                                                                                                             )}
                                                                                                                                        )}
                                                                                                                                   )} or
                                                                                                                                  {:typename,
                                                                                                                                   empty_list(),
                                                                                                                                   Zig.ErrorProng}
                                                                                                                              )}
                                                                                                                         ) or
                                                                                                                         non_empty_list(
                                                                                                                           non_empty_list(
                                                                                                                             {:when,
                                                                                                                              empty_list(),
                                                                                                                              non_empty_list(
                                                                                                                                {:is_binary,
                                                                                                                                 non_empty_list(
                                                                                                                                   {:context,
                                                                                                                                    Zig.ErrorProng} or
                                                                                                                                     {:imports,
                                                                                                                                      non_empty_list(
                                                                                                                                        {integer(),
                                                                                                                                         Kernel}
                                                                                                                                      )}
                                                                                                                                 ),
                                                                                                                                 non_empty_list(
                                                                                                                                   {:string,
                                                                                                                                    empty_list(),
                                                                                                                                    Zig.ErrorProng}
                                                                                                                                 )} or
                                                                                                                                  {:string,
                                                                                                                                   empty_list(),
                                                                                                                                   Zig.ErrorProng}
                                                                                                                              )}
                                                                                                                           ) or
                                                                                                                             {:string,
                                                                                                                              empty_list(),
                                                                                                                              Zig.ErrorProng}
                                                                                                                         ) or
                                                                                                                         non_empty_list(
                                                                                                                           non_empty_list(
                                                                                                                             {:when,
                                                                                                                              empty_list(),
                                                                                                                              non_empty_list(
                                                                                                                                {:is_list,
                                                                                                                                 non_empty_list(
                                                                                                                                   {:context,
                                                                                                                                    Zig.ErrorProng} or
                                                                                                                                     {:imports,
                                                                                                                                      non_empty_list(
                                                                                                                                        {integer(),
                                                                                                                                         Kernel}
                                                                                                                                      )}
                                                                                                                                 ),
                                                                                                                                 non_empty_list(
                                                                                                                                   {:list,
                                                                                                                                    empty_list(),
                                                                                                                                    Zig.ErrorProng}
                                                                                                                                 )} or
                                                                                                                                  {:list,
                                                                                                                                   empty_list(),
                                                                                                                                   Zig.ErrorProng}
                                                                                                                              )}
                                                                                                                           ) or
                                                                                                                             {:list,
                                                                                                                              empty_list(),
                                                                                                                              Zig.ErrorProng}
                                                                                                                         )}
                                                                                                                    )}
                                                                                                                 )}
                                                                                                            )} or
                                                                                                             {{:.,
                                                                                                               empty_list(),
                                                                                                               non_empty_list(
                                                                                                                 :wrap or
                                                                                                                   {:__aliases__,
                                                                                                                    non_empty_list(
                                                                                                                      {:alias,
                                                                                                                       false}
                                                                                                                    ),
                                                                                                                    non_empty_list(
                                                                                                                      :List
                                                                                                                    )}
                                                                                                               )},
                                                                                                              empty_list(),
                                                                                                              empty_list()}
                                                                                                         )} or
                                                                                                          {{:.,
                                                                                                            empty_list(),
                                                                                                            non_empty_list(
                                                                                                              :insert_at or
                                                                                                                {:__aliases__,
                                                                                                                 non_empty_list(
                                                                                                                   {:alias,
                                                                                                                    false}
                                                                                                                 ),
                                                                                                                 non_empty_list(
                                                                                                                   :List
                                                                                                                 )}
                                                                                                            )},
                                                                                                           empty_list(),
                                                                                                           non_empty_list(
                                                                                                             integer() or
                                                                                                               {{:.,
                                                                                                                 empty_list(),
                                                                                                                 non_empty_list(
                                                                                                                   {:indentation,
                                                                                                                    empty_list(),
                                                                                                                    Zig.ErrorProng}
                                                                                                                 )},
                                                                                                                empty_list(),
                                                                                                                non_empty_list(
                                                                                                                  {:indents,
                                                                                                                   empty_list(),
                                                                                                                   Zig.ErrorProng}
                                                                                                                )}
                                                                                                           )}
                                                                                                      )}
                                                                                                 )} or
                                                                                                  {non_empty_list(
                                                                                                     {:|,
                                                                                                      empty_list(),
                                                                                                      non_empty_list(
                                                                                                        {:error_msg or
                                                                                                           :so_far,
                                                                                                         empty_list(),
                                                                                                         Zig.ErrorProng}
                                                                                                      )}
                                                                                                   ),
                                                                                                   {:indents,
                                                                                                    empty_list(),
                                                                                                    Zig.ErrorProng}}
                                                                                              )}
                                                                                         )}
                                                                                    )} or
                                                                                     {empty_list(),
                                                                                      integer()}
                                                                                 )}
                                                                            )}
                                                                       )} or
                                                                        {{:., empty_list(),
                                                                          non_empty_list(
                                                                            :reverse or
                                                                              {:__aliases__,
                                                                               non_empty_list(
                                                                                 {:alias, false}
                                                                               ), non_empty_list(:Enum)}
                                                                          )}, empty_list(), empty_list()}
                                                                    )} or
                                                                     {{:., empty_list(),
                                                                       non_empty_list(
                                                                         :insert_at or
                                                                           {:__aliases__,
                                                                            non_empty_list(
                                                                              {:alias, false}
                                                                            ), non_empty_list(:List)}
                                                                       )}, empty_list(),
                                                                      non_empty_list(
                                                                        binary() or integer()
                                                                      )}
                                                                 )} or
                                                                  {{:., empty_list(),
                                                                    non_empty_list(
                                                                      :iodata_to_binary or
                                                                        {:__aliases__,
                                                                         non_empty_list({:alias, false}),
                                                                         non_empty_list(:IO)}
                                                                    )}, empty_list(), empty_list()}
                                                              )}}
                                                          )}} or {:file or :line, term()}
                                                    ) or {:opts, empty_list(), Zig.ErrorProng}
                                                  )}
                                             )}
                                      )}
                                 ) or
                                   non_empty_list(
                                     non_empty_list({:stacktrace, empty_list(), Zig.ErrorProng}) or
                                       {:stacktrace, empty_list(), Zig.ErrorProng}
                                   )}
                              )}
                           ) or {:__STACKTRACE__, empty_list(), Zig.ErrorProng}
                         )} or {:new_stacktrace, empty_list(), Zig.ErrorProng}
                      )} or
                       {{:., empty_list(), non_empty_list(:erlang or :raise)}, empty_list(),
                        non_empty_list(
                          :badarg or :error or {:new_stacktrace, empty_list(), Zig.ErrorProng}
                        )}
                   )}
              )}
           ), term()}
        )

    typing violation found at:
    \x{2502}
 48 \x{2502}         {[], []} -> []
    \x{2502}         ~~~~~~~~~~~~~~
    \x{2502}
    \x{2514}\x{2500} lib/zig/nif/threaded.ex:48: Zig.Nif.Threaded.render_elixir/1

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

No branches or pull requests

1 participant