I use the following code in ex_cldr to detect if Elixir is compiling. The mechanism changed from Elixir 1.11, hence the conditional check:

  def compiling? do
    # TODO: When we depend on Elixir v1.11+ only, remove function_exported and elixir_compiler_pid
    process_alive?(:can_await_module_compilation?) ||
      process_alive?(:elixir_compiler_pid)
  end

  defp process_alive?(:can_await_module_compilation?) do
    Code.ensure_loaded?(Code) &&
      function_exported?(Code, :can_await_module_compilation?, 0) &&
      apply(Code, :can_await_module_compilation?, [])
  end

  defp process_alive?(name) do
    case Process.get(name) do
      nil -> false
      pid when is_pid(pid) -> true
    end
  end

Please do not do this:

This is relying on internal compiler behaviour. Use the suggestions from @kip instead, which uses public APIs.

That distinction doesn’t change anything he said though, you can still generate a module at runtime and compile it and for it what is happening will be “compile time”. You really should revise what you really want to achieve with this and consider other ways, this can very easily bite you in the rear in the most inopportune moment in the future.

The problem is that it is pretty hard to differentiate between “compile time” and “run time” as “compile time” is “run time with saving created modules to .beam files”.

You can check __CALLER__.function to detect whether macro was called within function body or outside of it.

BEAM does not create files on its own, Elixir and Erlang compiler do if run under some special conditions (e. g. from the command line.)

If you are compiling files manually, you are responsible for persisting them, if you wish. Here I do it, because Common Test needs tests to be available as beams.

Basically, it’s

{module, code} = Code.compile_file(file)
beam = Path.join(Path.dirname(file), to_string(module) <> ".beam")
:ok = File.write!(Path.join(Path.dirname(file), to_string(module) <> ".beam"), code)