Where are you calling this from? Also why you are using the .exs extension that is for scripts?

I’m calling it from a handle_params function from a live view.

I used exs extension for no particular reason. I figured out the file option was only for debugging purposes

Yeah, so liveview render callbacks are kinda special, they are supposed to return a template, not an atom as in your case.

Without a specific example of how you are using it, it will be hard to determine what you are doing incorrectly. It does seem like you are missing a huge amount of prerequisites, like imports for views/liveviews/components, etc. in your module declaration.

I tried my module generation code somewhere else (outside the liveview), and it’s working.
Why is that?

What I’m trying to do is to generate my own liveviews dynamically at runtime.

Here is the full code of my generator:

def gen(page) do
    options = [
      engine: Phoenix.LiveView.TagEngine,
      caller: __ENV__,
      indentation: 2,
      file: "common_view.html.heex",
      line: 1,
      source: "common_view.html.heex",
      tag_handler: Phoenix.LiveView.HTMLEngine
    ]

    r = EEx.compile_file("lib/my_project_web/live/test_renderer_live/common_view.html.heex", options)

    mod_name = Module.concat(MyProjectWeb.TestRenderertLive.Pages, page)

    Module.create(
      mod_name,
      quote do
        def my_render(assigns) do
          unquote(r)
        end
      end,
      line: 1,
      file: "no_file.exs"
    )
  end

The idea is to call this my_render function in a generic LiveView using render_with.

The compilation of the HEEx template is working fine. I tried to execute Code.eval_quoted with the compiled template code and it’s working (it’s returning the expected Phoenix.LiveView.Rendered struct).

But when I try to set this compiled template inside my generated my_render function, I have another CompileError:

error: undefined variable "assigns"
└─ no_file.exs:1: MyProjectWeb.TestRenderertLive.Pages.TestPage.my_render/1

But assigns exists. It’s in the my_render function arguments.

The compiled template returns an AST in which the assigns variable is used this way (AST):

{:assigns, [], nil}

Is there something I can do to make my assigns variable visible to the compiled template?

I know my use case could be done a different way using eval_quoted in a “normal” render function, like this:

def handle_params(%{"page" => page}, _url, socket) do
    options = [
      engine: Phoenix.LiveView.TagEngine,
      caller: __ENV__,
      indentation: 2,
      file: "#{page}.html.heex",
      line: 1,
      source: "#{page}.html.heex",
      tag_handler: Phoenix.LiveView.HTMLEngine
    ]

    r = EEx.compile_file("lib/my_project_web/live/test_renderer_live/#{page}.html.heex", options)

    {:noreply,
     socket
     |> assign(:page, page)
     |> assign(:renderer, r)}
  end

def render(assigns) do
    {res, _bindings} =
      Code.eval_quoted(assigns.renderer, [assigns: assigns],
        line: 1,
        file: "#{assigns.page}.html.heex"
      )

    res
  end

But I’m trying the compiled way to optimize speed. I’d like to benchmark the 2 approches.

So I’d like to be able to compile a custom render function that contains the compiled template, and use it directly when the page is asked, instead of compiling the template at every page load.

Not sure what the endgame is, however phoenix does template compilation and caching out of the box, the only thing that always happens at runtime is template evaluation, which you want to be at runtime.

If you want to render a template at runtime, all you have to do is declare it correctly, this is the code you want to generate:

defmodule MyLiveview do
  use Phoenix.LiveView

  def render(assigns) do
    ~H"""
    <p>Hello, <%= @name %>!</p>
    """
  end
end

This is a generic example, it’s crucial that you use the heex sigil, otherwise you lose critical features of liveview templates, like change tracking.

If you decide to go lower level for whatever reason, it’s up to you to implement everything phoenix liveivew heex engine does for you, which I don’t recommend unless your scope is to use the templating engine for something else besides liveview.

I can try that, thank you.

I just thought it would be easier and proper the way I tried to do it:

• Compile the template (exactly what the ~H sigil does) to AST
• Generate my module and function, with the AST of the template inside (like using the ~H inside the render function)

But just for my understanding:

• do you know why my code did not work and was complaining about the unknown assigns variable?
• do you know why I had a cannot invoke remote function Phoenix.Component.Declarative.__pattern__!/2 inside a match error when I was trying to generate the function with an argument inside a liveview? (and why it was working when the function had no argument or when the generation code was moved to another module?)

These errors are very strange for me and I’d like to understand them

Try this in your macro:

def my_render(var!(assigns)) do

Thank you it solved my compile error!

I set your answer as the solution but answers from both of you helped me