Add Phoenix.LiveView.TagCompiler.Compiler

This commit introduces a compiler for the new unified
tree structure introduced in the previous commit. It
changes the TagEngine to use the new compiler and also
moves macro component handling to the parser.

For backwards compatibility, the TagEngine still implements
the EEx.Engine behaviour, but it is basically a no-op
(it will still parse Elixir expressions twice!)
and calls the new compiler at the end.

The benefit of this is that we can now have the full
tokenized template and handle macro components before
compiling inner parts of the template. This allows us
to more easily implement directives as explored by

#4114
#4116

Author: SteffenDE

lib/phoenix_component/macro_component.ex

@@ -151,90 +151,143 @@ defmodule Phoenix.Component.MacroComponent do
   end
 
   @doc false
-  def build_ast([{:tag, name, attrs, tag_meta} | rest], env) do
-    if closing = tag_meta[:closing] do
-      # we assert here because we don't expect any other values
-      true = closing in [:self, :void]
-    end
+  # Build macro AST from a tree node
+  # For self-closing: {:self_close, :tag, name, attrs, meta}
+  # For block: {:block, :tag, name, attrs, children, meta}
+  def build_ast({:self_close, :tag, name, attrs, meta}, env) do
+    closing_meta = Map.take(meta, [:closing])
+    {:ok, {name, do_attrs_to_macro_ast(attrs, env), [], closing_meta}}
+  catch
+    {:ast_error, message, error_meta} ->
+      {:error, message, error_meta}
+  end
 
-    meta = Map.take(tag_meta, [:closing])
-    build_ast(rest, [], [{name, token_attrs_to_ast(attrs, env), meta}], env)
+  def build_ast({:block, :tag, name, attrs, children, _meta}, env) do
+    children_ast = do_build_children_ast(children, env)
+    {:ok, {name, do_attrs_to_macro_ast(attrs, env), children_ast, %{}}}
+  catch
+    {:ast_error, message, error_meta} ->
+      {:error, message, error_meta}
   end
 
-  # recursive case: build_ast(tokens, acc, stack)
+  defp do_build_children_ast(children, env) do
+    Enum.map(children, fn
+      {:text, text, _meta} ->
+        text
 
-  # closing for final stack element -> done!
-  defp build_ast([{:close, :tag, _, _} | rest], acc, [{tag_name, attrs, meta}], _env) do
-    {:ok, {tag_name, attrs, Enum.reverse(acc), meta}, rest}
-  end
+      {:self_close, :tag, name, attrs, meta} ->
+        closing_meta = Map.take(meta, [:closing])
+        {name, do_attrs_to_macro_ast(attrs, env), [], closing_meta}
 
-  # tag open (self closing or void)
-  defp build_ast([{:tag, name, attrs, %{closing: type}} | rest], acc, stack, env)
-       when type in [:self, :void] do
-    acc = [{name, token_attrs_to_ast(attrs, env), [], %{closing: type}} | acc]
-    build_ast(rest, acc, stack, env)
-  end
+      {:block, :tag, name, attrs, nested_children, _meta} ->
+        {name, do_attrs_to_macro_ast(attrs, env), do_build_children_ast(nested_children, env),
+         %{}}
 
-  # tag open
-  defp build_ast([{:tag, name, attrs, _tag_meta} | rest], acc, stack, env) do
-    build_ast(rest, [], [{name, token_attrs_to_ast(attrs, env), %{}, acc} | stack], env)
-  end
+      {:self_close, type, _name, _attrs, meta}
+      when type in [:local_component, :remote_component] ->
+        throw({:ast_error, "function components cannot be nested inside a macro component", meta})
 
-  # tag close
-  defp build_ast(
-         [{:close, :tag, name, _tag_meta} | tokens],
-         acc,
-         [{name, attrs, meta, prev_acc} | stack],
-         env
-       ) do
-    build_ast(tokens, [{name, attrs, Enum.reverse(acc), meta} | prev_acc], stack, env)
-  end
+      {:block, type, _name, _attrs, _children, meta}
+      when type in [:local_component, :remote_component] ->
+        throw({:ast_error, "function components cannot be nested inside a macro component", meta})
 
-  # text
-  defp build_ast([{:text, text, _meta} | rest], acc, stack, env) do
-    build_ast(rest, [text | acc], stack, env)
-  end
+      {:self_close, :slot, _name, _attrs, meta} ->
+        throw({:ast_error, "slots cannot be nested inside a macro component", meta})
 
-  # unsupported token
-  defp build_ast([{type, _name, _attrs, meta} | _tokens], _acc, _stack, _env)
-       when type in [:local_component, :remote_component] do
-    {:error, "function components cannot be nested inside a macro component", meta}
-  end
+      {:block, :slot, _name, _attrs, _children, meta} ->
+        throw({:ast_error, "slots cannot be nested inside a macro component", meta})
 
-  defp build_ast([{:expr, _, _} | _], _acc, _stack, _env) do
-    # we raise here because we don't have a meta map (line + column) available
-    raise ArgumentError, "EEx is not currently supported in macro components"
-  end
+      {:body_expr, _expr, meta} ->
+        throw({:ast_error, "interpolation is not currently supported in macro components", meta})
 
-  defp build_ast([{:body_expr, _, meta} | _], _acc, _stack, _env) do
-    {:error, "interpolation is not currently supported in macro components", meta}
+      {:eex, _expr, meta} ->
+        throw({:ast_error, "EEx is not currently supported in macro components", meta})
+
+      {:eex_block, _expr, _blocks, meta} ->
+        throw({:ast_error, "EEx is not currently supported in macro components", meta})
+    end)
   end
 
-  defp token_attrs_to_ast(attrs, env) do
-    Enum.map(attrs, fn {name, value, _meta} ->
-      # for now, we don't support root expressions (<div {@foo}>)
-      if name == :root do
+  defp do_attrs_to_macro_ast(attrs, env) do
+    Enum.map(attrs, fn
+      {:root, value, attr_meta} ->
         format_attr = fn
           {:string, binary, _meta} -> binary
           {:expr, code, _meta} -> code
           nil -> "nil"
         end
 
-        raise ArgumentError,
-              "dynamic attributes are not supported in macro components, got: #{format_attr.(value)}"
-      end
+        throw(
+          {:ast_error,
+           "dynamic attributes are not supported in macro components, got: #{format_attr.(value)}",
+           attr_meta}
+        )
 
-      case value do
-        {:string, binary, _meta} ->
-          {name, binary}
+      {name, {:string, binary, _meta}, _attr_meta} ->
+        {name, binary}
 
-        {:expr, code, meta} ->
-          ast = Code.string_to_quoted!(code, line: meta.line, column: meta.column, file: env.file)
-          {name, ast}
+      {name, {:expr, code, expr_meta}, _attr_meta} ->
+        ast =
+          Code.string_to_quoted!(code,
+            line: expr_meta.line,
+            column: expr_meta.column,
+            file: env.file
+          )
 
-        nil ->
-          {name, nil}
-      end
+        {name, ast}
+
+      {name, nil, _attr_meta} ->
+        {name, nil}
+    end)
+  end
+
+  @doc false
+  # Convert macro AST back to tree nodes (parser format)
+  def macro_ast_to_tree({tag, attrs, [], %{closing: _closing} = meta}, parent_meta) do
+    tree_attrs = macro_ast_attrs_to_tree(attrs, parent_meta)
+    {:self_close, :tag, tag, tree_attrs, Map.merge(parent_meta, meta)}
+  end
+
+  def macro_ast_to_tree({tag, attrs, children, _meta}, parent_meta) do
+    tree_attrs = macro_ast_attrs_to_tree(attrs, parent_meta)
+    tree_children = Enum.map(children, &macro_ast_to_tree(&1, parent_meta))
+    {:block, :tag, tag, tree_attrs, tree_children, parent_meta}
+  end
+
+  def macro_ast_to_tree(text, parent_meta) when is_binary(text) do
+    {:text, text, parent_meta}
+  end
+
+  defp macro_ast_attrs_to_tree(attrs, meta) do
+    Enum.map(attrs, fn
+      {name, nil} ->
+        {name, nil, meta}
+
+      {name, value} when is_binary(value) ->
+        # Determine delimiter based on content (same logic as encode_binary_attribute)
+        delimiter =
+          case {:binary.match(value, ~s["]), :binary.match(value, "'")} do
+            {:nomatch, _} ->
+              ?"
+
+            {_, :nomatch} ->
+              ?'
+
+            _ ->
+              raise ArgumentError, """
+              invalid attribute value for "#{name}".
+              Attribute values must not contain single and double quotes at the same time.
+
+              You need to escape your attribute before using it in the MacroComponent AST. You can use `Phoenix.HTML.attributes_escape/1` to do so.
+              """
+          end
+
+        {name, {:string, value, Map.put(meta, :delimiter, delimiter)}, meta}
+
+      {name, ast} ->
+        # Convert quoted AST back to string for the tree node format
+        code = Macro.to_string(ast)
+        {name, {:expr, code, meta}, meta}
     end)
   end
 

lib/phoenix_live_view/html_engine.ex

@@ -22,15 +22,17 @@ defmodule Phoenix.LiveView.HTMLEngine do
     trim = Application.get_env(:phoenix, :trim_on_html_eex_engine, true)
     source = File.read!(path)
 
-    EEx.compile_string(source,
-      engine: Phoenix.LiveView.TagEngine,
-      line: 1,
+    options = [
+      engine: Phoenix.LiveView.Engine,
       file: path,
-      trim: trim,
+      line: 1,
       caller: __CALLER__,
       source: source,
-      tag_handler: __MODULE__
-    )
+      tag_handler: __MODULE__,
+      trim: trim
+    ]
+
+    Phoenix.LiveView.TagCompiler.compile(source, options)
   end
 
   @behaviour Phoenix.LiveView.TagEngine