Getting Line Error on stack trace when "using" modules

Questions / Help
, ,
1

I had a very large module (for my experience) with around 2k loc. I broke it down for organisational purposes, although I’m just “importing” these new modules into a main one. Now whenever I have an error that occurs in one of the modules being used I get the stack trace with the line where the module is imported, along with the function name and arity.

** (ArgumentError) could not put/update key nil on a nil value
    (elixir) lib/access.ex:371: Access.get_and_update/3
    (elixir) lib/kernel.ex:1880: Kernel.put_in/3
    (AetherWars) lib/aetherwars/duels/duels_processor.ex:12: AetherWars.Duels.Processor.decide_next_player/1
    (AetherWars) lib/aetherwars/duels/duels_processor.ex:11: AetherWars.Duels.Processor.pop_stack/4
    (AetherWars) lib/aetherwars/duels/duels_processor.ex:22: AetherWars.Duels.Processor.entry_point/4
    (AetherWars) web/channels/duel_channel.ex:25: AetherWars.DuelChannel.handle_in/3
    (phoenix) lib/phoenix/channel/server.ex:244: anonymous fn/4 in Phoenix.Channel.Server.handle_info/2
    (AetherWars) lib/aetherwars/endpoint.ex:1: AetherWars.Endpoint.instrument/4
    (stdlib) gen_server.erl:616: :gen_server.try_dispatch/4
    (stdlib) gen_server.erl:686: :gen_server.handle_msg/6
    (stdlib) proc_lib.erl:247: :proc_lib.init_p_do_apply/3

Sometimes this is all I need, but other times I have several different functions with the same arity pattern-matching on the head. Is there any way to be able to see in which line of the original module that has been used it occurs? (I guess since use when compiled basically places the code on the module calling it, it won’t be straightforward but perhaps there’s some easy work-around?)

You can see it becomes a bit problematic:

defmodule AetherWars.Duels.Processor do
  
  use AetherWars.Duels.Create
  use AetherWars.Duels.Utils
  use AetherWars.Duels.Payment
  use AetherWars.Duels.Legal
  use AetherWars.Duels.Messages
  use AetherWars.Duels.Strike
  use AetherWars.Duels.Guard
  use AetherWars.Duels.Stack
  use AetherWars.Duels.Turn
  use AetherWars.Duels.Manipulation
  use AetherWars.Duels.Battle
  alias AetherWars.Duels.Monitor
  ...
end

Any solution? Thanks

2 Likes
2

Hey! Large modules can definitely be a pain, but this is not the way to solve them. Find boundaries, break those things out into dedicated modules, then just have them each call each other.

5 Likes
3

@benwilson512 thanks for your input - and although I will probably end up doing that, I still think the error should be shown from its line on the used module and not the line where the use statement is (not sure how difficult it is to achieve in technical terms…).

1 Like
4

Generated code will use the stacktrace location of the caller. This is a good default for most macros since generated code should be kept to a minimum, the fact that you need the location of the generated code in the stacktrace is an indication that you are overusing it. Using use that expands to function definitions with the full implementation for composition is an anti-pattern.

If you do need the line information from the macros add location: :keep to the quoted code: quote location: :keep do ... end.

https://hexdocs.pm/elixir/Kernel.SpecialForms.html#quote/2-stacktrace-information

5 Likes
5

Thanks @ericmj - that indeed answers my question. I will nonetheless try organising my code in a different way, following ben’s and your advice - in my head - probably wrong - those functions would belong together in the same module, perhaps except messages and create, since they are all operations on the game state (but I will probably curse the future me about that choice).

1 Like
6

I’m guessing you want a single module as the public API and the module would be too large to have the implementations of all functions? If that’s the case look into using defdelegate Kernel — Elixir v1.16.0.

1 Like
7

@ericmj I don’t seem to understand the example provided in the docs,

defmodule MyList do
  defdelegate reverse(list), to: :lists
  defdelegate other_reverse(list), to: :lists, as: :reverse
end

MyList.reverse([1, 2, 3])
#=> [3, 2, 1]

MyList.other_reverse([1, 2, 3])
#=> [3, 2, 1]

But it’s still being called with MyList (the module where they’re defined?) and they “delegate” to :lists, which is?

In my case what I was aiming at was, for instance given:

defmodule AetherWars.Duels.Stack do
def place_in_stack(state, {"gift", player, %{"from" => from, "source" => uuid, "type" => type, "payment" => %{"payment" => payment}} = gift}) do
        with {:ok, g_scroll}  <- get_in_play(state, player, type, uuid, from),
             {:ok, g_gift}    <- legal_gift?(state, player, g_scroll, gift, from),
             {:ok, int_state} <- pay_cost(state, player, g_gift["cost"], payment),
             {:ok, new_state} <- place_gift_in_stack(int_state, player, g_gift, g_scroll, gift, from)
            do
              IO.puts("ready to pass priority after gift stack")
              pass_priority(new_state, player, switch_player(player))
        else
          {:error, msg, _} -> {:error, msg, state}
        end
      end
end

That I would be able to just call this function as place_in_stack from inside AetherWars.Duels.Processor, hence my usage of use.

Itself it calls functions from .Utils and .Legal, but ultimately I see them all as functions from Duels.Processor. Mostly because I’ve decided to always pass the game state, “state”(a json representation of the whole game) is always the first argument to any interaction so mentally I was seeing them as part of the same module, but due to the sheer size I wanted to break them out into different files for easier navigation (and editing).

Now I’m questioning if they should actually be different decoupled modules - but again they only make sense when dealing with a game state that is exactly this structure?

1 Like
8

When you use this way you actually define the functions inside the calling module. Why should they be defined there instead of the module where the code is located? What is wrong with calling functions at the module where they are located in the source code? If it’s annoying to prefix the module name before the function call maybe you should alias or import the module where the function is defined instead of moving the definition itself with use?

1 Like
9

Besides my mental model when projecting this (and having to change function calls in so many places), nothing is wrong with calling functions where they’re located in the source code - I tend to do that usually ah. alias still implies calling the module name, and import I think I tried but then I would need to “import” things in multiple places - like in the sample, I would need to import “utils” & “legal” & “payment” and then in “payment” and “legal” probably import “utils” again, and so on, otherwise they would break.

Perhaps it’s just bad architecture :slight_smile: but given that I’m creating it as I go and don’t have the whole engine yet designed/thought about…

Thanks for your patience and suggestions. I will give this some thought (to break it up in the future) - and for now just add the trace

1 Like