WIP

Author: zachdaniel

lib/volt/compiled.ex

@@ -0,0 +1,3 @@
+defmodule Volt.Compiled do
+  defstruct []
+end

lib/volt/compiler.ex

@@ -0,0 +1,14 @@
+defmodule Volt.Compiler do
+  def compile(dsl) do
+    render_expr = Volt.Info.volt_render!(dsl)
+
+    with {:ok, expr} <- Volt.Compiler.Passes.Inline.run(render_expr, dsl),
+         {:ok, expr} <- Volt.Compiler.Passes.IsolateLeafs.run(expr, dsl),
+         {:ok, expr} <- Volt.Compiler.Passes.MarkRecompute.run(expr, dsl) do
+      {:ok, expr} |> IO.inspect()
+      %Volt.Compiled{}
+    else
+      {:error, error} -> {:error, error}
+    end
+  end
+end

lib/volt/compiler/leaf.ex

@@ -0,0 +1,3 @@
+defmodule Volt.Compiler.Leaf do
+  defstruct [:expr]
+end

lib/volt/compiler/passes/inline.ex

@@ -0,0 +1,78 @@
+defmodule Volt.Compiler.Passes.Inline do
+  @moduledoc false
+
+  def run(expr, _dsl) do
+    {:ok, inline(expr)}
+  end
+
+  defp inline(expr) do
+    Macro.postwalk(expr, fn
+      {:volt, _meta, [component | rest]} = node ->
+        props_kw = List.first(rest) || []
+
+        case try_inline(component, props_kw) do
+          {:ok, inlined} -> inline(inlined)
+          :skip -> node
+        end
+
+      other ->
+        other
+    end)
+  end
+
+  defp try_inline(component, props_kw) do
+    with {:ok, module} <- resolve_module(component),
+         true <- props_only?(module) do
+      render_expr = Volt.Info.volt_render!(module)
+      prop_defs = Volt.Info.props(module)
+      prop_values = build_prop_values(prop_defs, props_kw)
+      {:ok, substitute_props(render_expr, prop_values)}
+    else
+      _ -> :skip
+    end
+  end
+
+  defp resolve_module({:__aliases__, _, parts}) do
+    module = Module.concat(parts)
+
+    case Code.ensure_loaded(module) do
+      {:module, ^module} -> {:ok, module}
+      _ -> :error
+    end
+  end
+
+  defp resolve_module(module) when is_atom(module) do
+    case Code.ensure_loaded(module) do
+      {:module, ^module} -> {:ok, module}
+      _ -> :error
+    end
+  end
+
+  defp resolve_module(_), do: :error
+
+  defp props_only?(module) do
+    function_exported?(module, :spark_dsl_config, 0) &&
+      Volt.Info.data(module) == [] &&
+      Volt.Info.props(module) != []
+  end
+
+  defp build_prop_values(prop_defs, props_kw) do
+    Map.new(prop_defs, fn prop ->
+      value = Keyword.get_lazy(props_kw, prop.name, fn -> Macro.escape(prop.default) end)
+      {prop.name, value}
+    end)
+  end
+
+  defp substitute_props(expr, prop_values) do
+    Macro.prewalk(expr, fn
+      {:@, _meta, [{name, _, ctx}]} when is_atom(name) and is_atom(ctx) ->
+        case Map.fetch(prop_values, name) do
+          {:ok, value} -> value
+          :error -> {:@, [], [{name, [], ctx}]}
+        end
+
+      other ->
+        other
+    end)
+  end
+end

lib/volt/compiler/passes/isolate_leafs.ex

@@ -0,0 +1,71 @@
+defmodule Volt.Compiler.Passes.IsolateLeafs do
+  alias Volt.Compiler.Leaf
+
+  def run(expr, dsl) do
+    has_data = Volt.Info.data(dsl) != []
+    has_props = Volt.Info.props(dsl) != []
+
+    if has_data or has_props do
+      case isolate_leafs(expr) do
+        {expr, true} -> {:ok, %Leaf{expr: expr}}
+        {expr, false} -> {:ok, expr}
+      end
+    else
+      {:ok, %Leaf{expr: expr}}
+    end
+  end
+
+  defp isolate_leafs({:@, _meta, _} = expr) do
+    {expr, false}
+  end
+
+  defp isolate_leafs({:volt, _meta, _} = expr) do
+    # TODO: inline static volts? Optimize somehow?
+    {expr, false}
+  end
+
+  defp isolate_leafs({fun, meta, args}) when is_list(args) do
+    {tagged, all_leafs} = reduce_tagged(args)
+
+    case all_leafs do
+      true -> {%Leaf{expr: {fun, meta, args}}, true}
+      false -> {{fun, meta, unwrap_tags(tagged)}, false}
+    end
+  end
+
+  defp isolate_leafs(list) when is_list(list) do
+    {tagged, all_leafs} = reduce_tagged(list)
+
+    case all_leafs do
+      true -> {%Leaf{expr: list}, true}
+      false -> {unwrap_tags(tagged), false}
+    end
+  end
+
+  defp isolate_leafs(tuple) when is_tuple(tuple) do
+    case isolate_leafs(Tuple.to_list(tuple)) do
+      {_list, true} -> {%Leaf{expr: tuple}, true}
+      {list, false} -> {List.to_tuple(list), false}
+    end
+  end
+
+  defp isolate_leafs(other), do: {other, true}
+
+  defp reduce_tagged(items) do
+    Enum.reduce(items, {[], true}, fn item, {acc, all_leafs} ->
+      case isolate_leafs(item) do
+        {expr, true} -> {[{expr, true} | acc], all_leafs}
+        {expr, false} -> {[{expr, false} | acc], false}
+      end
+    end)
+    |> then(fn {tagged, all_leafs} -> {Enum.reverse(tagged), all_leafs} end)
+  end
+
+  defp unwrap_tags(tagged) do
+    Enum.map(tagged, fn
+      {%Leaf{} = leaf, true} -> leaf
+      {expr, true} -> %Leaf{expr: expr}
+      {expr, false} -> expr
+    end)
+  end
+end

lib/volt/compiler/passes/mark_recompute.ex

@@ -0,0 +1,75 @@
+defmodule Volt.Compiler.Passes.MarkRecompute do
+  @moduledoc false
+  alias Volt.Compiler.{Leaf, Recompute}
+
+  def run(expr, dsl) do
+    prop_names = dsl |> Volt.Info.props() |> MapSet.new(& &1.name)
+
+    state_names =
+      dsl
+      |> Volt.Info.data()
+      |> Enum.filter(&is_struct(&1, Volt.Dsl.State))
+      |> MapSet.new(& &1.name)
+
+    recompute_names = MapSet.union(prop_names, state_names)
+
+    {result, _assigns} = mark(expr, recompute_names)
+    {:ok, result}
+  end
+
+  defp mark(%Leaf{} = leaf, _names), do: {leaf, []}
+
+  defp mark(%Recompute{} = r, _names), do: {r, r.assigns}
+
+  # volt() calls are component boundaries — don't wrap in Recompute,
+  # but poison parent nodes as dynamic
+  defp mark({:volt, _meta, _} = expr, _names), do: {expr, [:__dynamic__]}
+
+  defp mark({:@, _meta, [{name, _, ctx}]} = expr, names) when is_atom(name) and is_atom(ctx) do
+    if MapSet.member?(names, name) do
+      {%Recompute{assigns: [name], expr: expr}, [name]}
+    else
+      # pipe ref — not a recompute trigger, but poisons parent as dynamic
+      {expr, [:__dynamic__]}
+    end
+  end
+
+  defp mark({fun, meta, args}, names) when is_list(args) do
+    {new_args, assigns} = mark_children(args, names)
+    wrap_if_dynamic({fun, meta, new_args}, assigns)
+  end
+
+  defp mark(list, names) when is_list(list) do
+    {new_items, assigns} = mark_children(list, names)
+    wrap_if_dynamic(new_items, assigns)
+  end
+
+  defp mark(tuple, names) when is_tuple(tuple) do
+    {new_list, assigns} = mark_children(Tuple.to_list(tuple), names)
+    wrap_if_dynamic(List.to_tuple(new_list), assigns)
+  end
+
+  defp mark(other, _names), do: {other, []}
+
+  defp mark_children(items, names) do
+    Enum.map_reduce(items, [], fn item, acc ->
+      {new_item, assigns} = mark(item, names)
+      {new_item, acc ++ assigns}
+    end)
+  end
+
+  defp wrap_if_dynamic(expr, []), do: {expr, []}
+
+  defp wrap_if_dynamic(expr, assigns) do
+    real_assigns = assigns |> Enum.reject(&(&1 == :__dynamic__)) |> Enum.uniq()
+
+    case real_assigns do
+      [] ->
+        # dynamic (has volt/pipe children) but no recompute triggers
+        {expr, assigns}
+
+      _ ->
+        {%Recompute{assigns: real_assigns, expr: expr}, assigns}
+    end
+  end
+end

lib/volt/compiler/recompute.ex

@@ -0,0 +1,4 @@
+defmodule Volt.Compiler.Recompute do
+  @moduledoc false
+  defstruct [:assigns, :expr]
+end

lib/volt/transformers/compile_render.ex

@@ -5,7 +5,8 @@ defmodule Volt.Transformers.CompileRender do
   alias Spark.Dsl.Transformer
 
   def transform(dsl) do
-    render_expr = Transformer.get_option(dsl, [:volt], :render)
+    dsl |> Volt.Compiler.compile() |> IO.inspect()
+    render_expr = Volt.Info.volt_render!(dsl)
 
     if render_expr do
       transformed = transform_assigns(render_expr)

test/support/inline_test_components.ex

@@ -0,0 +1,29 @@
+defmodule Volt.Test.Greeting do
+  use Volt.Component
+
+  props do
+    prop(:name, :string, default: "World")
+  end
+
+  render("Hello, " <> @name)
+end
+
+defmodule Volt.Test.Wrapper do
+  use Volt.Component
+
+  props do
+    prop(:content, :string, default: "")
+  end
+
+  render(%{wrapped: @content})
+end
+
+defmodule Volt.Test.WithState do
+  use Volt.Component
+
+  data do
+    state(:x, :integer, default: 0)
+  end
+
+  render(%{x: @x})
+end

test/volt/compiler/passes/inline_test.exs

@@ -0,0 +1,84 @@
+defmodule Volt.Compiler.Passes.InlineTest do
+  use ExUnit.Case
+
+  alias Volt.Compiler.Passes.Inline
+
+  describe "props-only components" do
+    test "inlines render expression with prop substitution" do
+      expr = {:volt, [], [Volt.Test.Greeting, [name: "Zach"]]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      # Should be "Hello, " <> "Zach"
+      assert {:<>, _, ["Hello, ", "Zach"]} = result
+    end
+
+    test "uses default when prop not provided" do
+      expr = {:volt, [], [Volt.Test.Greeting]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      # Should be "Hello, " <> "World"
+      assert {:<>, _, ["Hello, ", "World"]} = result
+    end
+
+    test "substitutes AST expressions for props" do
+      expr = {:volt, [], [Volt.Test.Greeting, [name: {:@, [], [{:x, [], nil}]}]]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      # Should be "Hello, " <> @x
+      assert {:<>, _, ["Hello, ", {:@, _, [{:x, _, _}]}]} = result
+    end
+
+    test "inlines wrapper component" do
+      expr = {:volt, [], [Volt.Test.Wrapper, [content: "inner"]]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      # Should be %{wrapped: "inner"}
+      assert {:%{}, _, [{:wrapped, "inner"}]} = result
+    end
+  end
+
+  describe "components with data are NOT inlined" do
+    test "volt with state is left as-is" do
+      expr = {:volt, [], [Volt.Test.WithState]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      assert {:volt, _, [Volt.Test.WithState]} = result
+    end
+  end
+
+  describe "unresolvable modules are skipped" do
+    test "unknown module is left as-is" do
+      expr = {:volt, [], [{:__aliases__, [], [:NoSuchModule]}, [name: "hi"]]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      assert {:volt, _, _} = result
+    end
+  end
+
+  describe "nested inlining" do
+    test "recursively inlines nested props-only volts" do
+      # volt(Wrapper, content: volt(Greeting, name: "Zach"))
+      inner = {:volt, [], [Volt.Test.Greeting, [name: "Zach"]]}
+      expr = {:volt, [], [Volt.Test.Wrapper, [content: inner]]}
+      {:ok, result} = Inline.run(expr, nil)
+
+      # Wrapper inlines to %{wrapped: @content}
+      # @content was volt(Greeting, name: "Zach") which inlines to "Hello, " <> "Zach"
+      assert {:%{}, _, [{:wrapped, {:<>, _, ["Hello, ", "Zach"]}}]} = result
+    end
+  end
+
+  describe "mixed with non-inlineable content" do
+    test "inlines only props-only volts, leaves others" do
+      # [volt(Greeting, name: "A"), volt(WithState)]
+      expr = [
+        {:volt, [], [Volt.Test.Greeting, [name: "A"]]},
+        {:volt, [], [Volt.Test.WithState]}
+      ]
+
+      {:ok, result} = Inline.run(expr, nil)
+
+      assert [{:<>, _, ["Hello, ", "A"]}, {:volt, _, [Volt.Test.WithState]}] = result
+    end
+  end
+end